声明 模块 "http2" {

    //@@{ 事件组:events }
    导入 * 转为 事件组 来自 "events";
    导入 * 转为 fs 来自 "fs";

    //@@{ 网:net }
    导入 * 转为 网 来自 "net";

    //@@{ 流:stream }
    导入 * 转为 流 来自 "stream";
    导入 * 转为 tls 来自 "tls";
    导入 * 转为 url 来自 "url";

    //@@{ 传入的Http头_:IncomingHttpHeaders, Http1传入Http头_:Http1IncomingHttpHeaders }
    //@@{ 即将离开的Http头_:OutgoingHttpHeaders, 传入消息_:IncomingMessage, 服务器响应_:ServerResponse }
    导入 { 传入的Http头_ 转为 Http1传入Http头_, 即将离开的Http头_, 传入消息_, 服务器响应_ } 来自 "http";

    //@@{ 即将离开的Http头_:OutgoingHttpHeaders }
    导出 { 即将离开的Http头_ } 来自 "http";

    //@@{ 传入Http状态头_:IncomingHttpStatusHeader }
    导出 接口 传入Http状态头_ {
        
        //@@{ ":状态":":status" }
        ":状态"?: 数字;
    }

    //@@{ 传入的Http头_:IncomingHttpHeaders, Http1传入Http头_:Http1IncomingHttpHeaders }
    导出 接口 传入的Http头_ 扩展 Http1传入Http头_ {
        
        //@@{ ":路径":":path" }
        ":路径"?: 文字;
        
        //@@{ ":方法":":method" }
        ":方法"?: 文字;
        
        //@@{ ":权限":":authority" }
        ":权限"?: 文字;
        
        //@@{ ":计划":":scheme" }
        ":计划"?: 文字;
    }

    // Http2Stream

    //@@{ 流的优先级选项_:StreamPriorityOptions }
    导出 接口 流的优先级选项_ {

        //@@{ 相同描述符:exclusive }
        相同描述符?: 真假;

        //@@{ 父:parent }
        父?: 数字;

        //@@{ 权重:weight }
        权重?: 数字;

        //@@{ 沉默:silent }
        沉默?: 真假;
    }

    //@@{ 流状态_:StreamState }
    导出 接口 流状态_ {

        //@@{ 本地窗口大小:localWindowSize }
        本地窗口大小?: 数字;

        //@@{ 状态:state }
        状态?: 数字;

        //@@{ 局部闭合:localClose }
        局部闭合?: 数字;

        //@@{ 远程关闭:remoteClose }
        远程关闭?: 数字;

        //@@{ 依赖权重总和:sumDependencyWeight }
        依赖权重总和?: 数字;

        //@@{ 权重:weight }
        权重?: 数字;
    }

    //@@{ 服务器响应流选项_:ServerStreamResponseOptions }
    导出 接口 服务器响应流选项_ {

        //@@{ 结束流:endStream }
        结束流?: 真假;

        //@@{ 等待拖车:waitForTrailers }
        等待拖车?: 真假;
    }

    //@@{ 统计选项_:StatOptions }
    导出 接口 统计选项_ {

        //@@{ 偏移:offset }
        偏移: 数字;

        //@@{ 长度:length }
        长度: 数字;
    }

    //@@{ 服务器流文件响应选项_:ServerStreamFileResponseOptions }
    导出 接口 服务器流文件响应选项_ {

        //@@{ 统计检验:statCheck, 统计_:Stats, 即将离开的Http头_:OutgoingHttpHeaders, 统计选项_:StatOptions }
        统计检验?: (统计数据: fs.统计_, 报头: 即将离开的Http头_, 统计选项: 统计选项_) => 无值 | 真假;

        //@@{ 等待拖车:waitForTrailers }
        等待拖车?: 真假;

        //@@{ 偏移:offset }
        偏移?: 数字;

        //@@{ 长度:length }
        长度?: 数字;
    }

    //@@{ 服务器流文件响应选项出错_:ServerStreamFileResponseOptionsWithError, 服务器流文件响应选项_:ServerStreamFileResponseOptions }
    导出 接口 服务器流文件响应选项出错_ 扩展 服务器流文件响应选项_ {

        //@@{ 正在错误:onError, 错误异常_:ErrnoException }
        正在错误?: (错: NodeJS.错误异常_) => 无值;
    }

    //@@{ Http2流_:Http2Stream, 流:stream, 双工_:Duplex }
    导出 类别 Http2流_ 扩展 流.双工_ {
        保护 构造();

        //@@{ 中止的:aborted }
        只读 中止的: 真假;

        //@@{ 缓冲区大小:bufferSize }
        只读 缓冲区大小: 数字;

        //@@{ 关闭的:closed }
        只读 关闭的: 真假;

        //@@{ 摧毁了:destroyed }
        只读 摧毁了: 真假;
        /**
         * Set the true if the END_STREAM flag was set in the request or response HEADERS frame received,
         * indicating that no additional data should be received and the readable side of the Http2Stream will be closed.
         */

        //@@{ 结束后报头:endAfterHeaders }
        只读 结束后报头: 真假;

        //@@{ 待定:pending }
        只读 待定: 真假;

        //@@{ rst代码:rstCode }
        只读 rst代码: 数字;

        //@@{ 发送报头:sentHeaders, 即将离开的Http头_:OutgoingHttpHeaders }
        只读 发送报头: 即将离开的Http头_;

        //@@{ 发送的信息标题:sentInfoHeaders, 即将离开的Http头_:OutgoingHttpHeaders }
        只读 发送的信息标题?: 即将离开的Http头_[];

        //@@{ 发送的预告片:sentTrailers, 即将离开的Http头_:OutgoingHttpHeaders }
        只读 发送的预告片?: 即将离开的Http头_;

        //@@{ 会话:session, Http2会话_:Http2Session }
        只读 会话: Http2会话_;

        //@@{ 状态:state, 流状态_:StreamState }
        只读 状态: 流状态_;

        //@@{ 关闭:close }
        关闭(代码?: 数字, 回调?: () => 无值): 无值;

        //@@{ 优先级:priority, 流的优先级选项_:StreamPriorityOptions }
        优先级(选项组: 流的优先级选项_): 无值;

        //@@{ 设置超时:setTimeout }
        设置超时(毫秒断开: 数字, 回调?: () => 无值): 无值;

        //@@{ 发送预告片:sendTrailers, 即将离开的Http头_:OutgoingHttpHeaders }
        发送预告片(报头: 即将离开的Http头_): 无值;

        //@@{ 添加监听器:addListener, "中止的":"aborted" }
        添加监听器(事件: "中止的", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "关闭":"close" }
        添加监听器(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "数据":"data", 缓冲区_:Buffer }
        添加监听器(事件: "数据", 监听器: (块: 缓冲区_ | 文字) => 无值): 本体;

        //@@{ 添加监听器:addListener, "排空":"drain" }
        添加监听器(事件: "排空", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "结束":"end" }
        添加监听器(事件: "结束", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "错误":"error", 错误_:Error }
        添加监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "完成":"finish" }
        添加监听器(事件: "完成", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "帧错误":"frameError" }
        添加监听器(事件: "帧错误", 监听器: (框架类型: 数字, 错误代码: 数字) => 无值): 本体;

        //@@{ 添加监听器:addListener, "管道":"pipe", 流:stream, 可读的_:Readable }
        添加监听器(事件: "管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "取消管道":"unpipe", 流:stream, 可读的_:Readable }
        添加监听器(事件: "取消管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "流关闭":"streamClosed" }
        添加监听器(事件: "流关闭", 监听器: (代码: 数字) => 无值): 本体;

        //@@{ 添加监听器:addListener, "超时":"timeout" }
        添加监听器(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "预告":"trailers", 传入的Http头_:IncomingHttpHeaders }
        添加监听器(事件: "预告", 监听器: (预告: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 添加监听器:addListener, "想要预告片":"wantTrailers" }
        添加监听器(事件: "想要预告片", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener }
        添加监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 发出:emit, "中止的":"aborted" }
        发出(事件: "中止的"): 真假;

        //@@{ 发出:emit, "关闭":"close" }
        发出(事件: "关闭"): 真假;

        //@@{ 发出:emit, "数据":"data", 缓冲区_:Buffer }
        发出(事件: "数据", 块: 缓冲区_ | 文字): 真假;

        //@@{ 发出:emit, "排空":"drain" }
        发出(事件: "排空"): 真假;

        //@@{ 发出:emit, "结束":"end" }
        发出(事件: "结束"): 真假;

        //@@{ 发出:emit, "错误":"error", 错误_:Error }
        发出(事件: "错误", 错: 错误_): 真假;

        //@@{ 发出:emit, "完成":"finish" }
        发出(事件: "完成"): 真假;

        //@@{ 发出:emit, "帧错误":"frameError" }
        发出(事件: "帧错误", 框架类型: 数字, 错误代码: 数字): 真假;

        //@@{ 发出:emit, "管道":"pipe", 流:stream, 可读的_:Readable }
        发出(事件: "管道", 源: 流.可读的_): 真假;

        //@@{ 发出:emit, "取消管道":"unpipe", 流:stream, 可读的_:Readable }
        发出(事件: "取消管道", 源: 流.可读的_): 真假;

        //@@{ 发出:emit, "流关闭":"streamClosed" }
        发出(事件: "流关闭", 代码: 数字): 真假;

        //@@{ 发出:emit, "超时":"timeout" }
        发出(事件: "超时"): 真假;

        //@@{ 发出:emit, "预告":"trailers", 传入的Http头_:IncomingHttpHeaders }
        发出(事件: "预告", 预告: 传入的Http头_, 标志: 数字): 真假;

        //@@{ 发出:emit, "想要预告片":"wantTrailers" }
        发出(事件: "想要预告片"): 真假;

        //@@{ 发出:emit }
        发出(事件: 文字 | 符号, ...参数组: 任意[]): 真假;

        //@@{ 正在:on, "中止的":"aborted" }
        正在(事件: "中止的", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "关闭":"close" }
        正在(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "数据":"data", 缓冲区_:Buffer }
        正在(事件: "数据", 监听器: (块: 缓冲区_ | 文字) => 无值): 本体;

        //@@{ 正在:on, "排空":"drain" }
        正在(事件: "排空", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "结束":"end" }
        正在(事件: "结束", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "错误":"error", 错误_:Error }
        正在(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 正在:on, "完成":"finish" }
        正在(事件: "完成", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "帧错误":"frameError" }
        正在(事件: "帧错误", 监听器: (框架类型: 数字, 错误代码: 数字) => 无值): 本体;

        //@@{ 正在:on, "管道":"pipe", 流:stream, 可读的_:Readable }
        正在(事件: "管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 正在:on, "取消管道":"unpipe", 流:stream, 可读的_:Readable }
        正在(事件: "取消管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 正在:on, "流关闭":"streamClosed" }
        正在(事件: "流关闭", 监听器: (代码: 数字) => 无值): 本体;

        //@@{ 正在:on, "超时":"timeout" }
        正在(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "预告":"trailers", 传入的Http头_:IncomingHttpHeaders }
        正在(事件: "预告", 监听器: (预告: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 正在:on, "想要预告片":"wantTrailers" }
        正在(事件: "想要预告片", 监听器: () => 无值): 本体;

        //@@{ 正在:on }
        正在(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 一次:once, "中止的":"aborted" }
        一次(事件: "中止的", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "关闭":"close" }
        一次(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "数据":"data", 缓冲区_:Buffer }
        一次(事件: "数据", 监听器: (块: 缓冲区_ | 文字) => 无值): 本体;

        //@@{ 一次:once, "排空":"drain" }
        一次(事件: "排空", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "结束":"end" }
        一次(事件: "结束", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "错误":"error", 错误_:Error }
        一次(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 一次:once, "完成":"finish" }
        一次(事件: "完成", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "帧错误":"frameError" }
        一次(事件: "帧错误", 监听器: (框架类型: 数字, 错误代码: 数字) => 无值): 本体;

        //@@{ 一次:once, "管道":"pipe", 流:stream, 可读的_:Readable }
        一次(事件: "管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 一次:once, "取消管道":"unpipe", 流:stream, 可读的_:Readable }
        一次(事件: "取消管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 一次:once, "流关闭":"streamClosed" }
        一次(事件: "流关闭", 监听器: (代码: 数字) => 无值): 本体;

        //@@{ 一次:once, "超时":"timeout" }
        一次(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "预告":"trailers", 传入的Http头_:IncomingHttpHeaders }
        一次(事件: "预告", 监听器: (预告: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 一次:once, "想要预告片":"wantTrailers" }
        一次(事件: "想要预告片", 监听器: () => 无值): 本体;

        //@@{ 一次:once }
        一次(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "中止的":"aborted" }
        预处理监听器(事件: "中止的", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "关闭":"close" }
        预处理监听器(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "数据":"data", 缓冲区_:Buffer }
        预处理监听器(事件: "数据", 监听器: (块: 缓冲区_ | 文字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "排空":"drain" }
        预处理监听器(事件: "排空", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "结束":"end" }
        预处理监听器(事件: "结束", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "错误":"error", 错误_:Error }
        预处理监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "完成":"finish" }
        预处理监听器(事件: "完成", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "帧错误":"frameError" }
        预处理监听器(事件: "帧错误", 监听器: (框架类型: 数字, 错误代码: 数字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "管道":"pipe", 流:stream, 可读的_:Readable }
        预处理监听器(事件: "管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "取消管道":"unpipe", 流:stream, 可读的_:Readable }
        预处理监听器(事件: "取消管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "流关闭":"streamClosed" }
        预处理监听器(事件: "流关闭", 监听器: (代码: 数字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "超时":"timeout" }
        预处理监听器(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "预告":"trailers", 传入的Http头_:IncomingHttpHeaders }
        预处理监听器(事件: "预告", 监听器: (预告: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "想要预告片":"wantTrailers" }
        预处理监听器(事件: "想要预告片", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener }
        预处理监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "中止的":"aborted" }
        预处理一次监听器(事件: "中止的", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "关闭":"close" }
        预处理一次监听器(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "数据":"data", 缓冲区_:Buffer }
        预处理一次监听器(事件: "数据", 监听器: (块: 缓冲区_ | 文字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "排空":"drain" }
        预处理一次监听器(事件: "排空", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "结束":"end" }
        预处理一次监听器(事件: "结束", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "错误":"error", 错误_:Error }
        预处理一次监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "完成":"finish" }
        预处理一次监听器(事件: "完成", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "帧错误":"frameError" }
        预处理一次监听器(事件: "帧错误", 监听器: (框架类型: 数字, 错误代码: 数字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "管道":"pipe", 流:stream, 可读的_:Readable }
        预处理一次监听器(事件: "管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "取消管道":"unpipe", 流:stream, 可读的_:Readable }
        预处理一次监听器(事件: "取消管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "流关闭":"streamClosed" }
        预处理一次监听器(事件: "流关闭", 监听器: (代码: 数字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "超时":"timeout" }
        预处理一次监听器(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "预告":"trailers", 传入的Http头_:IncomingHttpHeaders }
        预处理一次监听器(事件: "预告", 监听器: (预告: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "想要预告片":"wantTrailers" }
        预处理一次监听器(事件: "想要预告片", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener }
        预处理一次监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;
    }

    //@@{ 客户端Http2流_:ClientHttp2Stream, Http2流_:Http2Stream }
    导出 类别 客户端Http2流_ 扩展 Http2流_ {
        私有 构造();

        //@@{ 添加监听器:addListener, "继续":"continue" }
        添加监听器(事件: "继续", 监听器: () => {}): 本体;

        //@@{ 添加监听器:addListener, "报头":"headers", 传入的Http头_:IncomingHttpHeaders }
        //@@{ 传入Http状态头_:IncomingHttpStatusHeader }
        添加监听器(事件: "报头", 监听器: (报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字) => 无值): 本体;

        //@@{ 添加监听器:addListener, "压入":"push", 传入的Http头_:IncomingHttpHeaders }
        添加监听器(事件: "压入", 监听器: (报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 添加监听器:addListener, "响应":"response", 传入的Http头_:IncomingHttpHeaders }
        //@@{ 传入Http状态头_:IncomingHttpStatusHeader }
        添加监听器(事件: "响应", 监听器: (报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字) => 无值): 本体;

        //@@{ 添加监听器:addListener }
        添加监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 发出:emit, "继续":"continue" }
        发出(事件: "继续"): 真假;

        //@@{ 发出:emit, "报头":"headers", 传入的Http头_:IncomingHttpHeaders, 传入Http状态头_:IncomingHttpStatusHeader }
        发出(事件: "报头", 报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字): 真假;

        //@@{ 发出:emit, "压入":"push", 传入的Http头_:IncomingHttpHeaders }
        发出(事件: "压入", 报头: 传入的Http头_, 标志: 数字): 真假;

        //@@{ 发出:emit, "响应":"response", 传入的Http头_:IncomingHttpHeaders, 传入Http状态头_:IncomingHttpStatusHeader }
        发出(事件: "响应", 报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字): 真假;

        //@@{ 发出:emit }
        发出(事件: 文字 | 符号, ...参数组: 任意[]): 真假;

        //@@{ 正在:on, "继续":"continue" }
        正在(事件: "继续", 监听器: () => {}): 本体;

        //@@{ 正在:on, "报头":"headers", 传入的Http头_:IncomingHttpHeaders, 传入Http状态头_:IncomingHttpStatusHeader }
        正在(事件: "报头", 监听器: (报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字) => 无值): 本体;

        //@@{ 正在:on, "压入":"push", 传入的Http头_:IncomingHttpHeaders }
        正在(事件: "压入", 监听器: (报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 正在:on, "响应":"response", 传入的Http头_:IncomingHttpHeaders, 传入Http状态头_:IncomingHttpStatusHeader }
        正在(事件: "响应", 监听器: (报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字) => 无值): 本体;

        //@@{ 正在:on }
        正在(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 一次:once, "继续":"continue" }
        一次(事件: "继续", 监听器: () => {}): 本体;

        //@@{ 一次:once, "报头":"headers", 传入的Http头_:IncomingHttpHeaders, 传入Http状态头_:IncomingHttpStatusHeader }
        一次(事件: "报头", 监听器: (报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字) => 无值): 本体;

        //@@{ 一次:once, "压入":"push", 传入的Http头_:IncomingHttpHeaders }
        一次(事件: "压入", 监听器: (报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 一次:once, "响应":"response", 传入的Http头_:IncomingHttpHeaders, 传入Http状态头_:IncomingHttpStatusHeader }
        一次(事件: "响应", 监听器: (报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字) => 无值): 本体;

        //@@{ 一次:once }
        一次(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "继续":"continue" }
        预处理监听器(事件: "继续", 监听器: () => {}): 本体;

        //@@{ 预处理监听器:prependListener, "报头":"headers", 传入的Http头_:IncomingHttpHeaders }
        //@@{ 传入Http状态头_:IncomingHttpStatusHeader }
        预处理监听器(事件: "报头", 监听器: (报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "压入":"push", 传入的Http头_:IncomingHttpHeaders }
        预处理监听器(事件: "压入", 监听器: (报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "响应":"response", 传入的Http头_:IncomingHttpHeaders }
        //@@{ 传入Http状态头_:IncomingHttpStatusHeader }
        预处理监听器(事件: "响应", 监听器: (报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener }
        预处理监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "继续":"continue" }
        预处理一次监听器(事件: "继续", 监听器: () => {}): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "报头":"headers", 传入的Http头_:IncomingHttpHeaders }
        //@@{ 传入Http状态头_:IncomingHttpStatusHeader }
        预处理一次监听器(事件: "报头", 监听器: (报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "压入":"push", 传入的Http头_:IncomingHttpHeaders }
        预处理一次监听器(事件: "压入", 监听器: (报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "响应":"response", 传入的Http头_:IncomingHttpHeaders }
        //@@{ 传入Http状态头_:IncomingHttpStatusHeader }
        预处理一次监听器(事件: "响应", 监听器: (报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener }
        预处理一次监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;
    }

    //@@{ 服务器Http2流_:ServerHttp2Stream, Http2流_:Http2Stream }
    导出 类别 服务器Http2流_ 扩展 Http2流_ {
        私有 构造();

        //@@{ 附加头:additionalHeaders, 即将离开的Http头_:OutgoingHttpHeaders }
        附加头(报头: 即将离开的Http头_): 无值;

        //@@{ 头发送:headersSent }
        只读 头发送: 真假;

        //@@{ 压入允许:pushAllowed }
        只读 压入允许: 真假;

        //@@{ 压入流:pushStream, 即将离开的Http头_:OutgoingHttpHeaders, 错误_:Error, 服务器Http2流_:ServerHttp2Stream }
        压入流(报头: 即将离开的Http头_, 回调?: (错: 错误_ | 空值, 压入流: 服务器Http2流_, 报头: 即将离开的Http头_) => 无值): 无值;

        //@@{ 压入流:pushStream, 即将离开的Http头_:OutgoingHttpHeaders, 流的优先级选项_:StreamPriorityOptions }
        //@@{ 错误_:Error, 服务器Http2流_:ServerHttp2Stream }
        压入流(报头: 即将离开的Http头_, 选项组?: 流的优先级选项_, 回调?: (错: 错误_ | 空值, 压入流: 服务器Http2流_, 报头: 即将离开的Http头_) => 无值): 无值;

        //@@{ 回应:respond, 即将离开的Http头_:OutgoingHttpHeaders, 服务器响应流选项_:ServerStreamResponseOptions }
        回应(报头?: 即将离开的Http头_, 选项组?: 服务器响应流选项_): 无值;

        //@@{ 回应按文件描述符:respondWithFD, 即将离开的Http头_:OutgoingHttpHeaders, 服务器流文件响应选项_:ServerStreamFileResponseOptions }
        回应按文件描述符(文件描述符: 数字, 报头?: 即将离开的Http头_, 选项组?: 服务器流文件响应选项_): 无值;

        //@@{ 回复按文件:respondWithFile, 即将离开的Http头_:OutgoingHttpHeaders, 服务器流文件响应选项出错_:ServerStreamFileResponseOptionsWithError }
        回复按文件(路径: 文字, 报头?: 即将离开的Http头_, 选项组?: 服务器流文件响应选项出错_): 无值;
    }

    // Http2Session

    //@@{ 配置_:Settings }
    导出 接口 配置_ {

        //@@{ 索引表大小:headerTableSize }
        索引表大小?: 数字;

        //@@{ 启用压入:enablePush }
        启用压入?: 真假;

        //@@{ 初始窗口大小:initialWindowSize }
        初始窗口大小?: 数字;

        //@@{ 最大框架大小:maxFrameSize }
        最大框架大小?: 数字;

        //@@{ 最大并发流:maxConcurrentStreams }
        最大并发流?: 数字;

        //@@{ 最大头列表大小:maxHeaderListSize }
        最大头列表大小?: 数字;

        //@@{ 启用连接协议:enableConnectProtocol }
        启用连接协议?: 真假;
    }

    //@@{ 客户端会话请求选项_:ClientSessionRequestOptions }
    导出 接口 客户端会话请求选项_ {

        //@@{ 结束流:endStream }
        结束流?: 真假;

        //@@{ 相同描述符:exclusive }
        相同描述符?: 真假;

        //@@{ 父:parent }
        父?: 数字;

        //@@{ 权重:weight }
        权重?: 数字;

        //@@{ 等待拖车:waitForTrailers }
        等待拖车?: 真假;
    }

    //@@{ 会话状态_:SessionState }
    导出 接口 会话状态_ {

        //@@{ 有效的本地窗口大小:effectiveLocalWindowSize }
        有效的本地窗口大小?: 数字;

        //@@{ 有效Recv数据长度:effectiveRecvDataLength }
        有效Recv数据长度?: 数字;

        //@@{ 下个流ID:nextStreamID }
        下个流ID?: 数字;

        //@@{ 本地窗口大小:localWindowSize }
        本地窗口大小?: 数字;

        //@@{ 最后处理流ID:lastProcStreamID }
        最后处理流ID?: 数字;

        //@@{ 远程窗口大小:remoteWindowSize }
        远程窗口大小?: 数字;

        //@@{ 出站队列大小:outboundQueueSize }
        出站队列大小?: 数字;

        //@@{ 抑制动态表大小:deflateDynamicTableSize }
        抑制动态表大小?: 数字;

        //@@{ 膨胀动态表大小:inflateDynamicTableSize }
        膨胀动态表大小?: 数字;
    }

    //@@{ Http2会话_:Http2Session, 事件组:events, 事件发生器_:EventEmitter }
    导出 类别 Http2会话_ 扩展 事件组.事件发生器_ {
        保护 构造();

        //@@{ alpn协议:alpnProtocol }
        只读 alpn协议?: 文字;

        //@@{ 关闭:close }
        关闭(回调?: () => 无值): 无值;

        //@@{ 关闭的:closed }
        只读 关闭的: 真假;

        //@@{ 连接中:connecting }
        只读 连接中: 真假;

        //@@{ 销毁:destroy, 错误_:Error }
        销毁(错误?: 错误_, 代码?: 数字): 无值;

        //@@{ 摧毁了:destroyed }
        只读 摧毁了: 真假;

        //@@{ 加密的:encrypted }
        只读 加密的?: 真假;

        //@@{ 消失:goaway, 缓冲区_:Buffer, 数据视图_:DataView, 类型数组_:TypedArray }
        消失(代码?: 数字, 最后流Id?: 数字, 不透明数据?: 缓冲区_ | 数据视图_ | NodeJS.类型数组_): 无值;

        //@@{ 本地配置:localSettings, 配置_:Settings }
        只读 本地配置: 配置_;

        //@@{ 原点集:originSet }
        只读 原点集?: 文字[];

        //@@{ 等待配置Ack:pendingSettingsAck }
        只读 等待配置Ack: 真假;

        //@@{ 平通:ping, 错误_:Error, 缓冲区_:Buffer }
        平通(回调: (错: 错误_ | 空值, 持续时间: 数字, 负载: 缓冲区_) => 无值): 真假;

        //@@{ 平通:ping, 缓冲区_:Buffer, 数据视图_:DataView, 类型数组_:TypedArray, 错误_:Error }
        平通(负载: 缓冲区_ | 数据视图_ | NodeJS.类型数组_ , 回调: (错: 错误_ | 空值, 持续时间: 数字, 负载: 缓冲区_) => 无值): 真假;

        //@@{ 限制退出:ref }
        限制退出(): 无值;

        //@@{ 远程配置:remoteSettings, 配置_:Settings }
        只读 远程配置: 配置_;

        //@@{ 设置超时:setTimeout }
        设置超时(毫秒断开: 数字, 回调?: () => 无值): 无值;

        //@@{ 套接字:socket, 网:net, 套接字_:Socket, TLS套接字_:TLSSocket }
        只读 套接字: 网.套接字_ | tls.TLS套接字_;

        //@@{ 状态:state, 会话状态_:SessionState }
        只读 状态: 会话状态_;

        //@@{ 配置:settings, 配置_:Settings }
        配置(配置: 配置_): 无值;

        //@@{ 类型:type }
        只读 类型: 数字;

        //@@{ 解除限制:unref }
        解除限制(): 无值;

        //@@{ 添加监听器:addListener, "关闭":"close" }
        添加监听器(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "错误":"error", 错误_:Error }
        添加监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "帧错误":"frameError" }
        添加监听器(事件: "帧错误", 监听器: (框架类型: 数字, 错误代码: 数字, 流Id: 数字) => 无值): 本体;

        //@@{ 添加监听器:addListener, "消失":"goaway", 缓冲区_:Buffer }
        添加监听器(事件: "消失", 监听器: (错误代码: 数字, 最后流Id: 数字, 不透明数据: 缓冲区_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "本地配置":"localSettings", 配置_:Settings }
        添加监听器(事件: "本地配置", 监听器: (配置: 配置_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "平通":"ping" }
        添加监听器(事件: "平通", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "远程配置":"remoteSettings", 配置_:Settings }
        添加监听器(事件: "远程配置", 监听器: (配置: 配置_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "超时":"timeout" }
        添加监听器(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener }
        添加监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 发出:emit, "关闭":"close" }
        发出(事件: "关闭"): 真假;

        //@@{ 发出:emit, "错误":"error", 错误_:Error }
        发出(事件: "错误", 错: 错误_): 真假;

        //@@{ 发出:emit, "帧错误":"frameError" }
        发出(事件: "帧错误", 框架类型: 数字, 错误代码: 数字, 流Id: 数字): 真假;

        //@@{ 发出:emit, "消失":"goaway", 缓冲区_:Buffer }
        发出(事件: "消失", 错误代码: 数字, 最后流Id: 数字, 不透明数据: 缓冲区_): 真假;

        //@@{ 发出:emit, "本地配置":"localSettings", 配置_:Settings }
        发出(事件: "本地配置", 配置: 配置_): 真假;

        //@@{ 发出:emit, "平通":"ping" }
        发出(事件: "平通"): 真假;

        //@@{ 发出:emit, "远程配置":"remoteSettings", 配置_:Settings }
        发出(事件: "远程配置", 配置: 配置_): 真假;

        //@@{ 发出:emit, "超时":"timeout" }
        发出(事件: "超时"): 真假;

        //@@{ 发出:emit }
        发出(事件: 文字 | 符号, ...参数组: 任意[]): 真假;

        //@@{ 正在:on, "关闭":"close" }
        正在(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "错误":"error", 错误_:Error }
        正在(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 正在:on, "帧错误":"frameError" }
        正在(事件: "帧错误", 监听器: (框架类型: 数字, 错误代码: 数字, 流Id: 数字) => 无值): 本体;

        //@@{ 正在:on, "消失":"goaway", 缓冲区_:Buffer }
        正在(事件: "消失", 监听器: (错误代码: 数字, 最后流Id: 数字, 不透明数据: 缓冲区_) => 无值): 本体;

        //@@{ 正在:on, "本地配置":"localSettings", 配置_:Settings }
        正在(事件: "本地配置", 监听器: (配置: 配置_) => 无值): 本体;

        //@@{ 正在:on, "平通":"ping" }
        正在(事件: "平通", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "远程配置":"remoteSettings", 配置_:Settings }
        正在(事件: "远程配置", 监听器: (配置: 配置_) => 无值): 本体;

        //@@{ 正在:on, "超时":"timeout" }
        正在(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 正在:on }
        正在(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 一次:once, "关闭":"close" }
        一次(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "错误":"error", 错误_:Error }
        一次(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 一次:once, "帧错误":"frameError" }
        一次(事件: "帧错误", 监听器: (框架类型: 数字, 错误代码: 数字, 流Id: 数字) => 无值): 本体;

        //@@{ 一次:once, "消失":"goaway", 缓冲区_:Buffer }
        一次(事件: "消失", 监听器: (错误代码: 数字, 最后流Id: 数字, 不透明数据: 缓冲区_) => 无值): 本体;

        //@@{ 一次:once, "本地配置":"localSettings", 配置_:Settings }
        一次(事件: "本地配置", 监听器: (配置: 配置_) => 无值): 本体;

        //@@{ 一次:once, "平通":"ping" }
        一次(事件: "平通", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "远程配置":"remoteSettings", 配置_:Settings }
        一次(事件: "远程配置", 监听器: (配置: 配置_) => 无值): 本体;

        //@@{ 一次:once, "超时":"timeout" }
        一次(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 一次:once }
        一次(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "关闭":"close" }
        预处理监听器(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "错误":"error", 错误_:Error }
        预处理监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "帧错误":"frameError" }
        预处理监听器(事件: "帧错误", 监听器: (框架类型: 数字, 错误代码: 数字, 流Id: 数字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "消失":"goaway", 缓冲区_:Buffer }
        预处理监听器(事件: "消失", 监听器: (错误代码: 数字, 最后流Id: 数字, 不透明数据: 缓冲区_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "本地配置":"localSettings", 配置_:Settings }
        预处理监听器(事件: "本地配置", 监听器: (配置: 配置_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "平通":"ping" }
        预处理监听器(事件: "平通", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "远程配置":"remoteSettings", 配置_:Settings }
        预处理监听器(事件: "远程配置", 监听器: (配置: 配置_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "超时":"timeout" }
        预处理监听器(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener }
        预处理监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "关闭":"close" }
        预处理一次监听器(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "错误":"error", 错误_:Error }
        预处理一次监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "帧错误":"frameError" }
        预处理一次监听器(事件: "帧错误", 监听器: (框架类型: 数字, 错误代码: 数字, 流Id: 数字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "消失":"goaway", 缓冲区_:Buffer }
        预处理一次监听器(事件: "消失", 监听器: (错误代码: 数字, 最后流Id: 数字, 不透明数据: 缓冲区_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "本地配置":"localSettings", 配置_:Settings }
        预处理一次监听器(事件: "本地配置", 监听器: (配置: 配置_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "平通":"ping" }
        预处理一次监听器(事件: "平通", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "远程配置":"remoteSettings", 配置_:Settings }
        预处理一次监听器(事件: "远程配置", 监听器: (配置: 配置_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "超时":"timeout" }
        预处理一次监听器(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener }
        预处理一次监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;
    }

    //@@{ 客户端Http2会话_:ClientHttp2Session, Http2会话_:Http2Session }
    导出 类别 客户端Http2会话_ 扩展 Http2会话_ {
        私有 构造();

        //@@{ 请求:request, 即将离开的Http头_:OutgoingHttpHeaders, 客户端会话请求选项_:ClientSessionRequestOptions }
        //@@{ 客户端Http2流_:ClientHttp2Stream }
        请求(报头?: 即将离开的Http头_, 选项组?: 客户端会话请求选项_): 客户端Http2流_;

        //@@{ 添加监听器:addListener, "替代服务":"altsvc" }
        添加监听器(事件: "替代服务", 监听器: (描述: 文字, 起点: 文字, 流: 数字) => 无值): 本体;

        //@@{ 添加监听器:addListener, "起点":"origin" }
        添加监听器(事件: "起点", 监听器: (起源: 文字[]) => 无值): 本体;

        //@@{ 添加监听器:addListener, "连接":"connect", 客户端Http2会话_:ClientHttp2Session }
        //@@{ 网:net, 套接字_:Socket, TLS套接字_:TLSSocket }
        添加监听器(事件: "连接", 监听器: (会话: 客户端Http2会话_, 套接字: 网.套接字_ | tls.TLS套接字_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "流":"stream", 客户端Http2流_:ClientHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        //@@{ 传入Http状态头_:IncomingHttpStatusHeader }
        添加监听器(事件: "流", 监听器: (流: 客户端Http2流_, 报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字) => 无值): 本体;

        //@@{ 添加监听器:addListener }
        添加监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 发出:emit, "替代服务":"altsvc" }
        发出(事件: "替代服务", 描述: 文字, 起点: 文字, 流: 数字): 真假;

        //@@{ 发出:emit, "起点":"origin" }
        发出(事件: "起点", 起源: 文字[]): 真假;

        //@@{ 发出:emit, "连接":"connect", 客户端Http2会话_:ClientHttp2Session, 网:net, 套接字_:Socket }
        //@@{ TLS套接字_:TLSSocket }
        发出(事件: "连接", 会话: 客户端Http2会话_, 套接字: 网.套接字_ | tls.TLS套接字_): 真假;

        //@@{ 发出:emit, "流":"stream", 客户端Http2流_:ClientHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        //@@{ 传入Http状态头_:IncomingHttpStatusHeader }
        发出(事件: "流", 流: 客户端Http2流_, 报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字): 真假;

        //@@{ 发出:emit }
        发出(事件: 文字 | 符号, ...参数组: 任意[]): 真假;

        //@@{ 正在:on, "替代服务":"altsvc" }
        正在(事件: "替代服务", 监听器: (描述: 文字, 起点: 文字, 流: 数字) => 无值): 本体;

        //@@{ 正在:on, "起点":"origin" }
        正在(事件: "起点", 监听器: (起源: 文字[]) => 无值): 本体;

        //@@{ 正在:on, "连接":"connect", 客户端Http2会话_:ClientHttp2Session, 网:net, 套接字_:Socket }
        //@@{ TLS套接字_:TLSSocket }
        正在(事件: "连接", 监听器: (会话: 客户端Http2会话_, 套接字: 网.套接字_ | tls.TLS套接字_) => 无值): 本体;

        //@@{ 正在:on, "流":"stream", 客户端Http2流_:ClientHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        //@@{ 传入Http状态头_:IncomingHttpStatusHeader }
        正在(事件: "流", 监听器: (流: 客户端Http2流_, 报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字) => 无值): 本体;

        //@@{ 正在:on }
        正在(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 一次:once, "替代服务":"altsvc" }
        一次(事件: "替代服务", 监听器: (描述: 文字, 起点: 文字, 流: 数字) => 无值): 本体;

        //@@{ 一次:once, "起点":"origin" }
        一次(事件: "起点", 监听器: (起源: 文字[]) => 无值): 本体;

        //@@{ 一次:once, "连接":"connect", 客户端Http2会话_:ClientHttp2Session, 网:net, 套接字_:Socket }
        //@@{ TLS套接字_:TLSSocket }
        一次(事件: "连接", 监听器: (会话: 客户端Http2会话_, 套接字: 网.套接字_ | tls.TLS套接字_) => 无值): 本体;

        //@@{ 一次:once, "流":"stream", 客户端Http2流_:ClientHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        //@@{ 传入Http状态头_:IncomingHttpStatusHeader }
        一次(事件: "流", 监听器: (流: 客户端Http2流_, 报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字) => 无值): 本体;

        //@@{ 一次:once }
        一次(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "替代服务":"altsvc" }
        预处理监听器(事件: "替代服务", 监听器: (描述: 文字, 起点: 文字, 流: 数字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "起点":"origin" }
        预处理监听器(事件: "起点", 监听器: (起源: 文字[]) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "连接":"connect", 客户端Http2会话_:ClientHttp2Session }
        //@@{ 网:net, 套接字_:Socket, TLS套接字_:TLSSocket }
        预处理监听器(事件: "连接", 监听器: (会话: 客户端Http2会话_, 套接字: 网.套接字_ | tls.TLS套接字_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "流":"stream", 客户端Http2流_:ClientHttp2Stream }
        //@@{ 传入的Http头_:IncomingHttpHeaders, 传入Http状态头_:IncomingHttpStatusHeader }
        预处理监听器(事件: "流", 监听器: (流: 客户端Http2流_, 报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener }
        预处理监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "替代服务":"altsvc" }
        预处理一次监听器(事件: "替代服务", 监听器: (描述: 文字, 起点: 文字, 流: 数字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "起点":"origin" }
        预处理一次监听器(事件: "起点", 监听器: (起源: 文字[]) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "连接":"connect", 客户端Http2会话_:ClientHttp2Session }
        //@@{ 网:net, 套接字_:Socket, TLS套接字_:TLSSocket }
        预处理一次监听器(事件: "连接", 监听器: (会话: 客户端Http2会话_, 套接字: 网.套接字_ | tls.TLS套接字_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "流":"stream", 客户端Http2流_:ClientHttp2Stream }
        //@@{ 传入的Http头_:IncomingHttpHeaders, 传入Http状态头_:IncomingHttpStatusHeader }
        预处理一次监听器(事件: "流", 监听器: (流: 客户端Http2流_, 报头: 传入的Http头_ & 传入Http状态头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener }
        预处理一次监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;
    }

    //@@{ 替代服务选项_:AlternativeServiceOptions }
    导出 接口 替代服务选项_ {

        //@@{ 起点:origin }
        起点: 数字 | 文字 | url.URL;
    }

    //@@{ 服务器Http2会话_:ServerHttp2Session, Http2会话_:Http2Session }
    导出 类别 服务器Http2会话_ 扩展 Http2会话_ {
        私有 构造();

        //@@{ 替代服务选项_:AlternativeServiceOptions }
        altsvc(描述: 文字, 源或流: 数字 | 文字 | url.URL | 替代服务选项_): 无值;

        //@@{ 起点:origin, 数组_:Array }
        起点(...参数组: 数组_<文字 | url.URL | { 起点: 文字 }>): 无值;

        //@@{ 服务器:server, Http2服务器_:Http2Server, Http2安全服务器_:Http2SecureServer }
        只读 服务器: Http2服务器_ | Http2安全服务器_;

        //@@{ 添加监听器:addListener, "连接":"connect", 服务器Http2会话_:ServerHttp2Session }
        //@@{ 网:net, 套接字_:Socket, TLS套接字_:TLSSocket }
        添加监听器(事件: "连接", 监听器: (会话: 服务器Http2会话_, 套接字: 网.套接字_ | tls.TLS套接字_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "流":"stream", 服务器Http2流_:ServerHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        添加监听器(事件: "流", 监听器: (流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 添加监听器:addListener }
        添加监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 发出:emit, "连接":"connect", 服务器Http2会话_:ServerHttp2Session, 网:net, 套接字_:Socket }
        //@@{ TLS套接字_:TLSSocket }
        发出(事件: "连接", 会话: 服务器Http2会话_, 套接字: 网.套接字_ | tls.TLS套接字_): 真假;

        //@@{ 发出:emit, "流":"stream", 服务器Http2流_:ServerHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        发出(事件: "流", 流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字): 真假;

        //@@{ 发出:emit }
        发出(事件: 文字 | 符号, ...参数组: 任意[]): 真假;

        //@@{ 正在:on, "连接":"connect", 服务器Http2会话_:ServerHttp2Session, 网:net, 套接字_:Socket }
        //@@{ TLS套接字_:TLSSocket }
        正在(事件: "连接", 监听器: (会话: 服务器Http2会话_, 套接字: 网.套接字_ | tls.TLS套接字_) => 无值): 本体;

        //@@{ 正在:on, "流":"stream", 服务器Http2流_:ServerHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        正在(事件: "流", 监听器: (流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 正在:on }
        正在(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 一次:once, "连接":"connect", 服务器Http2会话_:ServerHttp2Session, 网:net, 套接字_:Socket }
        //@@{ TLS套接字_:TLSSocket }
        一次(事件: "连接", 监听器: (会话: 服务器Http2会话_, 套接字: 网.套接字_ | tls.TLS套接字_) => 无值): 本体;

        //@@{ 一次:once, "流":"stream", 服务器Http2流_:ServerHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        一次(事件: "流", 监听器: (流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 一次:once }
        一次(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "连接":"connect", 服务器Http2会话_:ServerHttp2Session }
        //@@{ 网:net, 套接字_:Socket, TLS套接字_:TLSSocket }
        预处理监听器(事件: "连接", 监听器: (会话: 服务器Http2会话_, 套接字: 网.套接字_ | tls.TLS套接字_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "流":"stream", 服务器Http2流_:ServerHttp2Stream }
        //@@{ 传入的Http头_:IncomingHttpHeaders }
        预处理监听器(事件: "流", 监听器: (流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener }
        预处理监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "连接":"connect", 服务器Http2会话_:ServerHttp2Session }
        //@@{ 网:net, 套接字_:Socket, TLS套接字_:TLSSocket }
        预处理一次监听器(事件: "连接", 监听器: (会话: 服务器Http2会话_, 套接字: 网.套接字_ | tls.TLS套接字_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "流":"stream", 服务器Http2流_:ServerHttp2Stream }
        //@@{ 传入的Http头_:IncomingHttpHeaders }
        预处理一次监听器(事件: "流", 监听器: (流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener }
        预处理一次监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;
    }

    // Http2Server

    //@@{ 会话选项_:SessionOptions }
    导出 接口 会话选项_ {

        //@@{ 最大压缩动态表大小:maxDeflateDynamicTableSize }
        最大压缩动态表大小?: 数字;

        //@@{ 最大会话内存:maxSessionMemory }
        最大会话内存?: 数字;

        //@@{ 最大标题列表对数:maxHeaderListPairs }
        最大标题列表对数?: 数字;

        //@@{ 最大未完成平通组:maxOutstandingPings }
        最大未完成平通组?: 数字;

        //@@{ 最大发送头块长度:maxSendHeaderBlockLength }
        最大发送头块长度?: 数字;

        //@@{ 填充策略:paddingStrategy }
        填充策略?: 数字;

        //@@{ 对等最大并发流:peerMaxConcurrentStreams }
        对等最大并发流?: 数字;

        //@@{ 选择填充:selectPadding }
        选择填充?: (框架长度: 数字, 最大框架长度: 数字) => 数字;

        //@@{ 配置:settings, 配置_:Settings }
        配置?: 配置_;

        //@@{ 创建连接:createConnection, 会话选项_:SessionOptions, 流:stream, 双工_:Duplex }
        创建连接?: (权威: url.URL, 选项: 会话选项_) => 流.双工_;
    }

    //@@{ 客户端会话选项_:ClientSessionOptions, 会话选项_:SessionOptions }
    导出 接口 客户端会话选项_ 扩展 会话选项_ {

        //@@{ 最大保留远程流:maxReservedRemoteStreams }
        最大保留远程流?: 数字;

        //@@{ 创建连接:createConnection, 会话选项_:SessionOptions, 流:stream, 双工_:Duplex }
        创建连接?: (权威: url.URL, 选项: 会话选项_) => 流.双工_;
    }

    //@@{ 服务器会话选项_:ServerSessionOptions, 会话选项_:SessionOptions }
    导出 接口 服务器会话选项_ 扩展 会话选项_ {

        //@@{ Http1传入消息_:Http1IncomingMessage, 传入消息_:IncomingMessage }
        Http1传入消息_?: 类为 传入消息_;

        //@@{ Http1服务器响应_:Http1ServerResponse, 服务器响应_:ServerResponse }
        Http1服务器响应_?: 类为 服务器响应_;

        //@@{ Http2服务器请求_:Http2ServerRequest }
        Http2服务器请求_?: 类为 Http2服务器请求_;

        //@@{ Http2服务器响应_:Http2ServerResponse }
        Http2服务器响应_?: 类为 Http2服务器响应_;
    }

    //@@{ 安全客户端会话选项_:SecureClientSessionOptions, 客户端会话选项_:ClientSessionOptions }
    //@@{ 连接选项_:ConnectionOptions }
    导出 接口 安全客户端会话选项_ 扩展 客户端会话选项_, tls.连接选项_ { }

    //@@{ 安全服务器会话选项_:SecureServerSessionOptions, 服务器会话选项_:ServerSessionOptions }
    //@@{ Tls选项_:TlsOptions }
    导出 接口 安全服务器会话选项_ 扩展 服务器会话选项_, tls.Tls选项_ { }

    //@@{ 服务器选项_:ServerOptions, 服务器会话选项_:ServerSessionOptions }
    导出 接口 服务器选项_ 扩展 服务器会话选项_ { }

    //@@{ 安全服务器选项_:SecureServerOptions, 安全服务器会话选项_:SecureServerSessionOptions }
    导出 接口 安全服务器选项_ 扩展 安全服务器会话选项_ {

        //@@{ 允许HTTP1:allowHTTP1 }
        允许HTTP1?: 真假;

        //@@{ 起源:origins }
        起源?: 文字[];
    }

    //@@{ Http2服务器_:Http2Server, 网:net, 服务器_:Server }
    导出 类别 Http2服务器_ 扩展 网.服务器_ {
        私有 构造();

        //@@{ 添加监听器:addListener, Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse, "检查继续":"checkContinue" }
        添加监听器(事件: "检查继续", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "请求":"request", Http2服务器请求_:Http2ServerRequest }
        //@@{ Http2服务器响应_:Http2ServerResponse }
        添加监听器(事件: "请求", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "会话":"session", 服务器Http2会话_:ServerHttp2Session }
        添加监听器(事件: "会话", 监听器: (会话: 服务器Http2会话_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "会话错误":"sessionError", 错误_:Error }
        添加监听器(事件: "会话错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "流":"stream", 服务器Http2流_:ServerHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        添加监听器(事件: "流", 监听器: (流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 添加监听器:addListener, "超时":"timeout" }
        添加监听器(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener }
        添加监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 发出:emit, Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse, "检查继续":"checkContinue" }
        发出(事件: "检查继续", 请求: Http2服务器请求_, 响应: Http2服务器响应_): 真假;

        //@@{ 发出:emit, "请求":"request", Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse }
        发出(事件: "请求", 请求: Http2服务器请求_, 响应: Http2服务器响应_): 真假;

        //@@{ 发出:emit, "会话":"session", 服务器Http2会话_:ServerHttp2Session }
        发出(事件: "会话", 会话: 服务器Http2会话_): 真假;

        //@@{ 发出:emit, "会话错误":"sessionError", 错误_:Error }
        发出(事件: "会话错误", 错: 错误_): 真假;

        //@@{ 发出:emit, "流":"stream", 服务器Http2流_:ServerHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        发出(事件: "流", 流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字): 真假;

        //@@{ 发出:emit, "超时":"timeout" }
        发出(事件: "超时"): 真假;

        //@@{ 发出:emit }
        发出(事件: 文字 | 符号, ...参数组: 任意[]): 真假;

        //@@{ 正在:on, Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse, "检查继续":"checkContinue" }
        正在(事件: "检查继续", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 正在:on, "请求":"request", Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse }
        正在(事件: "请求", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 正在:on, "会话":"session", 服务器Http2会话_:ServerHttp2Session }
        正在(事件: "会话", 监听器: (会话: 服务器Http2会话_) => 无值): 本体;

        //@@{ 正在:on, "会话错误":"sessionError", 错误_:Error }
        正在(事件: "会话错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 正在:on, "流":"stream", 服务器Http2流_:ServerHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        正在(事件: "流", 监听器: (流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 正在:on, "超时":"timeout" }
        正在(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 正在:on }
        正在(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 一次:once, Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse, "检查继续":"checkContinue" }
        一次(事件: "检查继续", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 一次:once, "请求":"request", Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse }
        一次(事件: "请求", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 一次:once, "会话":"session", 服务器Http2会话_:ServerHttp2Session }
        一次(事件: "会话", 监听器: (会话: 服务器Http2会话_) => 无值): 本体;

        //@@{ 一次:once, "会话错误":"sessionError", 错误_:Error }
        一次(事件: "会话错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 一次:once, "流":"stream", 服务器Http2流_:ServerHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        一次(事件: "流", 监听器: (流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 一次:once, "超时":"timeout" }
        一次(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 一次:once }
        一次(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse, "检查继续":"checkContinue" }
        预处理监听器(事件: "检查继续", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "请求":"request", Http2服务器请求_:Http2ServerRequest }
        //@@{ Http2服务器响应_:Http2ServerResponse }
        预处理监听器(事件: "请求", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "会话":"session", 服务器Http2会话_:ServerHttp2Session }
        预处理监听器(事件: "会话", 监听器: (会话: 服务器Http2会话_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "会话错误":"sessionError", 错误_:Error }
        预处理监听器(事件: "会话错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "流":"stream", 服务器Http2流_:ServerHttp2Stream }
        //@@{ 传入的Http头_:IncomingHttpHeaders }
        预处理监听器(事件: "流", 监听器: (流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "超时":"timeout" }
        预处理监听器(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener }
        预处理监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse, "检查继续":"checkContinue" }
        预处理一次监听器(事件: "检查继续", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "请求":"request", Http2服务器请求_:Http2ServerRequest }
        //@@{ Http2服务器响应_:Http2ServerResponse }
        预处理一次监听器(事件: "请求", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "会话":"session", 服务器Http2会话_:ServerHttp2Session }
        预处理一次监听器(事件: "会话", 监听器: (会话: 服务器Http2会话_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "会话错误":"sessionError", 错误_:Error }
        预处理一次监听器(事件: "会话错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "流":"stream", 服务器Http2流_:ServerHttp2Stream }
        //@@{ 传入的Http头_:IncomingHttpHeaders }
        预处理一次监听器(事件: "流", 监听器: (流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "超时":"timeout" }
        预处理一次监听器(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener }
        预处理一次监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 设置超时:setTimeout }
        设置超时(msec?: 数字, 回调?: () => 无值): 本体;
    }

    //@@{ Http2安全服务器_:Http2SecureServer, 服务器_:Server }
    导出 类别 Http2安全服务器_ 扩展 tls.服务器_ {
        私有 构造();

        //@@{ 添加监听器:addListener, Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse, "检查继续":"checkContinue" }
        添加监听器(事件: "检查继续", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "请求":"request", Http2服务器请求_:Http2ServerRequest }
        //@@{ Http2服务器响应_:Http2ServerResponse }
        添加监听器(事件: "请求", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "会话":"session", 服务器Http2会话_:ServerHttp2Session }
        添加监听器(事件: "会话", 监听器: (会话: 服务器Http2会话_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "会话错误":"sessionError", 错误_:Error }
        添加监听器(事件: "会话错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "流":"stream", 服务器Http2流_:ServerHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        添加监听器(事件: "流", 监听器: (流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 添加监听器:addListener, "超时":"timeout" }
        添加监听器(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "未知协议":"unknownProtocol", TLS套接字_:TLSSocket }
        添加监听器(事件: "未知协议", 监听器: (套接字: tls.TLS套接字_) => 无值): 本体;

        //@@{ 添加监听器:addListener }
        添加监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 发出:emit, Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse, "检查继续":"checkContinue" }
        发出(事件: "检查继续", 请求: Http2服务器请求_, 响应: Http2服务器响应_): 真假;

        //@@{ 发出:emit, "请求":"request", Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse }
        发出(事件: "请求", 请求: Http2服务器请求_, 响应: Http2服务器响应_): 真假;

        //@@{ 发出:emit, "会话":"session", 服务器Http2会话_:ServerHttp2Session }
        发出(事件: "会话", 会话: 服务器Http2会话_): 真假;

        //@@{ 发出:emit, "会话错误":"sessionError", 错误_:Error }
        发出(事件: "会话错误", 错: 错误_): 真假;

        //@@{ 发出:emit, "流":"stream", 服务器Http2流_:ServerHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        发出(事件: "流", 流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字): 真假;

        //@@{ 发出:emit, "超时":"timeout" }
        发出(事件: "超时"): 真假;

        //@@{ 发出:emit, "未知协议":"unknownProtocol", TLS套接字_:TLSSocket }
        发出(事件: "未知协议", 套接字: tls.TLS套接字_): 真假;

        //@@{ 发出:emit }
        发出(事件: 文字 | 符号, ...参数组: 任意[]): 真假;

        //@@{ 正在:on, Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse, "检查继续":"checkContinue" }
        正在(事件: "检查继续", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 正在:on, "请求":"request", Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse }
        正在(事件: "请求", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 正在:on, "会话":"session", 服务器Http2会话_:ServerHttp2Session }
        正在(事件: "会话", 监听器: (会话: 服务器Http2会话_) => 无值): 本体;

        //@@{ 正在:on, "会话错误":"sessionError", 错误_:Error }
        正在(事件: "会话错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 正在:on, "流":"stream", 服务器Http2流_:ServerHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        正在(事件: "流", 监听器: (流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 正在:on, "超时":"timeout" }
        正在(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "未知协议":"unknownProtocol", TLS套接字_:TLSSocket }
        正在(事件: "未知协议", 监听器: (套接字: tls.TLS套接字_) => 无值): 本体;

        //@@{ 正在:on }
        正在(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 一次:once, Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse, "检查继续":"checkContinue" }
        一次(事件: "检查继续", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 一次:once, "请求":"request", Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse }
        一次(事件: "请求", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 一次:once, "会话":"session", 服务器Http2会话_:ServerHttp2Session }
        一次(事件: "会话", 监听器: (会话: 服务器Http2会话_) => 无值): 本体;

        //@@{ 一次:once, "会话错误":"sessionError", 错误_:Error }
        一次(事件: "会话错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 一次:once, "流":"stream", 服务器Http2流_:ServerHttp2Stream, 传入的Http头_:IncomingHttpHeaders }
        一次(事件: "流", 监听器: (流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 一次:once, "超时":"timeout" }
        一次(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "未知协议":"unknownProtocol", TLS套接字_:TLSSocket }
        一次(事件: "未知协议", 监听器: (套接字: tls.TLS套接字_) => 无值): 本体;

        //@@{ 一次:once }
        一次(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse, "检查继续":"checkContinue" }
        预处理监听器(事件: "检查继续", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "请求":"request", Http2服务器请求_:Http2ServerRequest }
        //@@{ Http2服务器响应_:Http2ServerResponse }
        预处理监听器(事件: "请求", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "会话":"session", 服务器Http2会话_:ServerHttp2Session }
        预处理监听器(事件: "会话", 监听器: (会话: 服务器Http2会话_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "会话错误":"sessionError", 错误_:Error }
        预处理监听器(事件: "会话错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "流":"stream", 服务器Http2流_:ServerHttp2Stream }
        //@@{ 传入的Http头_:IncomingHttpHeaders }
        预处理监听器(事件: "流", 监听器: (流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "超时":"timeout" }
        预处理监听器(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "未知协议":"unknownProtocol", TLS套接字_:TLSSocket }
        预处理监听器(事件: "未知协议", 监听器: (套接字: tls.TLS套接字_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener }
        预处理监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse, "检查继续":"checkContinue" }
        预处理一次监听器(事件: "检查继续", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "请求":"request", Http2服务器请求_:Http2ServerRequest }
        //@@{ Http2服务器响应_:Http2ServerResponse }
        预处理一次监听器(事件: "请求", 监听器: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "会话":"session", 服务器Http2会话_:ServerHttp2Session }
        预处理一次监听器(事件: "会话", 监听器: (会话: 服务器Http2会话_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "会话错误":"sessionError", 错误_:Error }
        预处理一次监听器(事件: "会话错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "流":"stream", 服务器Http2流_:ServerHttp2Stream }
        //@@{ 传入的Http头_:IncomingHttpHeaders }
        预处理一次监听器(事件: "流", 监听器: (流: 服务器Http2流_, 报头: 传入的Http头_, 标志: 数字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "超时":"timeout" }
        预处理一次监听器(事件: "超时", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "未知协议":"unknownProtocol", TLS套接字_:TLSSocket }
        预处理一次监听器(事件: "未知协议", 监听器: (套接字: tls.TLS套接字_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener }
        预处理一次监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 设置超时:setTimeout }
        设置超时(msec?: 数字, 回调?: () => 无值): 本体;
    }

    //@@{ Http2服务器请求_:Http2ServerRequest, 流:stream, 可读的_:Readable }
    导出 类别 Http2服务器请求_ 扩展 流.可读的_ {
        私有 构造();

        //@@{ 中止的:aborted }
        只读 中止的: 真假;

        //@@{ 权威:authority }
        只读 权威: 文字;

        //@@{ 报头:headers, 传入的Http头_:IncomingHttpHeaders }
        只读 报头: 传入的Http头_;

        //@@{ http版本:httpVersion }
        只读 http版本: 文字;

        //@@{ 方法:method }
        只读 方法: 文字;

        //@@{ 原始头组:rawHeaders }
        只读 原始头组: 文字[];

        //@@{ 原始预告组:rawTrailers }
        只读 原始预告组: 文字[];

        //@@{ 计划:scheme }
        只读 计划: 文字;

        //@@{ 设置超时:setTimeout }
        设置超时(毫秒断开: 数字, 回调?: () => 无值): 无值;

        //@@{ 套接字:socket, 网:net, 套接字_:Socket, TLS套接字_:TLSSocket }
        只读 套接字: 网.套接字_ | tls.TLS套接字_;

        //@@{ 流:stream, 服务器Http2流_:ServerHttp2Stream }
        只读 流: 服务器Http2流_;

        //@@{ 预告:trailers, 传入的Http头_:IncomingHttpHeaders }
        只读 预告: 传入的Http头_;
        只读 url: 文字;

        //@@{ 读:read, 缓冲区_:Buffer }
        读(大小?: 数字): 缓冲区_ | 文字 | 空值;

        //@@{ 添加监听器:addListener, "中止的":"aborted" }
        添加监听器(事件: "中止的", 监听器: (有错误: 真假, 代码: 数字) => 无值): 本体;

        //@@{ 添加监听器:addListener, "关闭":"close" }
        添加监听器(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "数据":"data", 缓冲区_:Buffer }
        添加监听器(事件: "数据", 监听器: (块: 缓冲区_ | 文字) => 无值): 本体;

        //@@{ 添加监听器:addListener, "结束":"end" }
        添加监听器(事件: "结束", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "可读的":"readable" }
        添加监听器(事件: "可读的", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "错误":"error", 错误_:Error }
        添加监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 添加监听器:addListener }
        添加监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 发出:emit, "中止的":"aborted" }
        发出(事件: "中止的", 有错误: 真假, 代码: 数字): 真假;

        //@@{ 发出:emit, "关闭":"close" }
        发出(事件: "关闭"): 真假;

        //@@{ 发出:emit, "数据":"data", 缓冲区_:Buffer }
        发出(事件: "数据", 块: 缓冲区_ | 文字): 真假;

        //@@{ 发出:emit, "结束":"end" }
        发出(事件: "结束"): 真假;

        //@@{ 发出:emit, "可读的":"readable" }
        发出(事件: "可读的"): 真假;

        //@@{ 发出:emit, "错误":"error", 错误_:Error }
        发出(事件: "错误", 错: 错误_): 真假;

        //@@{ 发出:emit }
        发出(事件: 文字 | 符号, ...参数组: 任意[]): 真假;

        //@@{ 正在:on, "中止的":"aborted" }
        正在(事件: "中止的", 监听器: (有错误: 真假, 代码: 数字) => 无值): 本体;

        //@@{ 正在:on, "关闭":"close" }
        正在(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "数据":"data", 缓冲区_:Buffer }
        正在(事件: "数据", 监听器: (块: 缓冲区_ | 文字) => 无值): 本体;

        //@@{ 正在:on, "结束":"end" }
        正在(事件: "结束", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "可读的":"readable" }
        正在(事件: "可读的", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "错误":"error", 错误_:Error }
        正在(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 正在:on }
        正在(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 一次:once, "中止的":"aborted" }
        一次(事件: "中止的", 监听器: (有错误: 真假, 代码: 数字) => 无值): 本体;

        //@@{ 一次:once, "关闭":"close" }
        一次(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "数据":"data", 缓冲区_:Buffer }
        一次(事件: "数据", 监听器: (块: 缓冲区_ | 文字) => 无值): 本体;

        //@@{ 一次:once, "结束":"end" }
        一次(事件: "结束", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "可读的":"readable" }
        一次(事件: "可读的", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "错误":"error", 错误_:Error }
        一次(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 一次:once }
        一次(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "中止的":"aborted" }
        预处理监听器(事件: "中止的", 监听器: (有错误: 真假, 代码: 数字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "关闭":"close" }
        预处理监听器(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "数据":"data", 缓冲区_:Buffer }
        预处理监听器(事件: "数据", 监听器: (块: 缓冲区_ | 文字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "结束":"end" }
        预处理监听器(事件: "结束", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "可读的":"readable" }
        预处理监听器(事件: "可读的", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "错误":"error", 错误_:Error }
        预处理监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener }
        预处理监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "中止的":"aborted" }
        预处理一次监听器(事件: "中止的", 监听器: (有错误: 真假, 代码: 数字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "关闭":"close" }
        预处理一次监听器(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "数据":"data", 缓冲区_:Buffer }
        预处理一次监听器(事件: "数据", 监听器: (块: 缓冲区_ | 文字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "结束":"end" }
        预处理一次监听器(事件: "结束", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "可读的":"readable" }
        预处理一次监听器(事件: "可读的", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "错误":"error", 错误_:Error }
        预处理一次监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener }
        预处理一次监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;
    }

    //@@{ Http2服务器响应_:Http2ServerResponse, 流:stream, 流_:Stream }
    导出 类别 Http2服务器响应_ 扩展 流.流_ {
        私有 构造();

        //@@{ 添加预告:addTrailers, 即将离开的Http头_:OutgoingHttpHeaders }
        添加预告(预告: 即将离开的Http头_): 无值;

        //@@{ 连接:connection, 网:net, 套接字_:Socket, TLS套接字_:TLSSocket }
        只读 连接: 网.套接字_ | tls.TLS套接字_;

        //@@{ 结束:end }
        结束(回调?: () => 无值): 无值;

        //@@{ 结束:end, 缓冲区_:Buffer, 正整数数组8_:Uint8Array }
        结束(数据: 文字 | 缓冲区_ | 正整数数组8_, 回调?: () => 无值): 无值;

        //@@{ 结束:end, 缓冲区_:Buffer, 正整数数组8_:Uint8Array }
        结束(数据: 文字 | 缓冲区_ | 正整数数组8_, 编码: 文字, 回调?: () => 无值): 无值;

        //@@{ 完成了:finished }
        只读 完成了: 真假;

        //@@{ 获取头:getHeader }
        获取头(名称: 文字): 文字;

        //@@{ 获取头名字:getHeaderNames }
        获取头名字(): 文字[];

        //@@{ 获取头集:getHeaders, 即将离开的Http头_:OutgoingHttpHeaders }
        获取头集(): 即将离开的Http头_;

        //@@{ 具有头:hasHeader }
        具有头(名称: 文字): 真假;

        //@@{ 头发送:headersSent }
        只读 头发送: 真假;

        //@@{ 删除头:removeHeader }
        删除头(名称: 文字): 无值;

        //@@{ 发送日期:sendDate }
        发送日期: 真假;

        //@@{ 设置头:setHeader }
        设置头(名称: 文字, 值: 数字 | 文字 | 文字[]): 无值;

        //@@{ 设置超时:setTimeout }
        设置超时(毫秒断开: 数字, 回调?: () => 无值): 无值;

        //@@{ 套接字:socket, 网:net, 套接字_:Socket, TLS套接字_:TLSSocket }
        只读 套接字: 网.套接字_ | tls.TLS套接字_;

        //@@{ 状态代码:statusCode }
        状态代码: 数字;

        //@@{ 状态消息:statusMessage }
        状态消息: "";

        //@@{ 流:stream, 服务器Http2流_:ServerHttp2Stream }
        只读 流: 服务器Http2流_;

        //@@{ 写:write, 缓冲区_:Buffer, 正整数数组8_:Uint8Array, 错误_:Error }
        写(块: 文字 | 缓冲区_ | 正整数数组8_, 回调?: (错: 错误_) => 无值): 真假;

        //@@{ 写:write, 缓冲区_:Buffer, 正整数数组8_:Uint8Array, 错误_:Error }
        写(块: 文字 | 缓冲区_ | 正整数数组8_, 编码: 文字, 回调?: (错: 错误_) => 无值): 真假;

        //@@{ 写继续:writeContinue }
        写继续(): 无值;

        //@@{ 写头:writeHead, 即将离开的Http头_:OutgoingHttpHeaders }
        写头(状态代码: 数字, 报头?: 即将离开的Http头_): 本体;

        //@@{ 写头:writeHead, 即将离开的Http头_:OutgoingHttpHeaders }
        写头(状态代码: 数字, 状态消息: 文字, 报头?: 即将离开的Http头_): 本体;

        //@@{ 创建压入响应:createPushResponse, 即将离开的Http头_:OutgoingHttpHeaders, 错误_:Error }
        //@@{ Http2服务器响应_:Http2ServerResponse }
        创建压入响应(报头: 即将离开的Http头_, 回调: (错: 错误_ | 空值, 响应: Http2服务器响应_) => 无值): 无值;

        //@@{ 添加监听器:addListener, "关闭":"close" }
        添加监听器(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "排空":"drain" }
        添加监听器(事件: "排空", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "错误":"error", 错误_:Error }
        添加监听器(事件: "错误", 监听器: (错误: 错误_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "完成":"finish" }
        添加监听器(事件: "完成", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "管道":"pipe", 流:stream, 可读的_:Readable }
        添加监听器(事件: "管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "取消管道":"unpipe", 流:stream, 可读的_:Readable }
        添加监听器(事件: "取消管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 添加监听器:addListener }
        添加监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 发出:emit, "关闭":"close" }
        发出(事件: "关闭"): 真假;

        //@@{ 发出:emit, "排空":"drain" }
        发出(事件: "排空"): 真假;

        //@@{ 发出:emit, "错误":"error", 错误_:Error }
        发出(事件: "错误", 错误: 错误_): 真假;

        //@@{ 发出:emit, "完成":"finish" }
        发出(事件: "完成"): 真假;

        //@@{ 发出:emit, "管道":"pipe", 流:stream, 可读的_:Readable }
        发出(事件: "管道", 源: 流.可读的_): 真假;

        //@@{ 发出:emit, "取消管道":"unpipe", 流:stream, 可读的_:Readable }
        发出(事件: "取消管道", 源: 流.可读的_): 真假;

        //@@{ 发出:emit }
        发出(事件: 文字 | 符号, ...参数组: 任意[]): 真假;

        //@@{ 正在:on, "关闭":"close" }
        正在(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "排空":"drain" }
        正在(事件: "排空", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "错误":"error", 错误_:Error }
        正在(事件: "错误", 监听器: (错误: 错误_) => 无值): 本体;

        //@@{ 正在:on, "完成":"finish" }
        正在(事件: "完成", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "管道":"pipe", 流:stream, 可读的_:Readable }
        正在(事件: "管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 正在:on, "取消管道":"unpipe", 流:stream, 可读的_:Readable }
        正在(事件: "取消管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 正在:on }
        正在(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 一次:once, "关闭":"close" }
        一次(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "排空":"drain" }
        一次(事件: "排空", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "错误":"error", 错误_:Error }
        一次(事件: "错误", 监听器: (错误: 错误_) => 无值): 本体;

        //@@{ 一次:once, "完成":"finish" }
        一次(事件: "完成", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "管道":"pipe", 流:stream, 可读的_:Readable }
        一次(事件: "管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 一次:once, "取消管道":"unpipe", 流:stream, 可读的_:Readable }
        一次(事件: "取消管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 一次:once }
        一次(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "关闭":"close" }
        预处理监听器(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "排空":"drain" }
        预处理监听器(事件: "排空", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "错误":"error", 错误_:Error }
        预处理监听器(事件: "错误", 监听器: (错误: 错误_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "完成":"finish" }
        预处理监听器(事件: "完成", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "管道":"pipe", 流:stream, 可读的_:Readable }
        预处理监听器(事件: "管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "取消管道":"unpipe", 流:stream, 可读的_:Readable }
        预处理监听器(事件: "取消管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener }
        预处理监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "关闭":"close" }
        预处理一次监听器(事件: "关闭", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "排空":"drain" }
        预处理一次监听器(事件: "排空", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "错误":"error", 错误_:Error }
        预处理一次监听器(事件: "错误", 监听器: (错误: 错误_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "完成":"finish" }
        预处理一次监听器(事件: "完成", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "管道":"pipe", 流:stream, 可读的_:Readable }
        预处理一次监听器(事件: "管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "取消管道":"unpipe", 流:stream, 可读的_:Readable }
        预处理一次监听器(事件: "取消管道", 监听器: (源: 流.可读的_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener }
        预处理一次监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;
    }

    // Public API

    //@@{ 常量组:constants }
    导出 名域 常量组 {

        //@@{ __NGHTTP2_会话_服务器__:NGHTTP2_SESSION_SERVER }
        常量 __NGHTTP2_会话_服务器__: 数字;

        //@@{ __NGHTTP2_会话_客户端__:NGHTTP2_SESSION_CLIENT }
        常量 __NGHTTP2_会话_客户端__: 数字;

        //@@{ __NGHTTP2_流_状态_闲置__:NGHTTP2_STREAM_STATE_IDLE }
        常量 __NGHTTP2_流_状态_闲置__: 数字;

        //@@{ __NGHTTP2_流_状态_打开__:NGHTTP2_STREAM_STATE_OPEN }
        常量 __NGHTTP2_流_状态_打开__: 数字;

        //@@{ __NGHTTP2_流_状态_保留_本地__:NGHTTP2_STREAM_STATE_RESERVED_LOCAL }
        常量 __NGHTTP2_流_状态_保留_本地__: 数字;

        //@@{ __NGHTTP2_流_状态_保留_远程__:NGHTTP2_STREAM_STATE_RESERVED_REMOTE }
        常量 __NGHTTP2_流_状态_保留_远程__: 数字;

        //@@{ __NGHTTP2_流_状态_一半_关闭_本地__:NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL }
        常量 __NGHTTP2_流_状态_一半_关闭_本地__: 数字;

        //@@{ __NGHTTP2_流_状态_一半_关闭_远程__:NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE }
        常量 __NGHTTP2_流_状态_一半_关闭_远程__: 数字;

        //@@{ __NGHTTP2_流_状态_关闭__:NGHTTP2_STREAM_STATE_CLOSED }
        常量 __NGHTTP2_流_状态_关闭__: 数字;

        //@@{ __NGHTTP2_没有_错误__:NGHTTP2_NO_ERROR }
        常量 __NGHTTP2_没有_错误__: 数字;

        //@@{ __NGHTTP2_协议_错误__:NGHTTP2_PROTOCOL_ERROR }
        常量 __NGHTTP2_协议_错误__: 数字;

        //@@{ __NGHTTP2_内部_错误__:NGHTTP2_INTERNAL_ERROR }
        常量 __NGHTTP2_内部_错误__: 数字;

        //@@{ __NGHTTP2_流_控制_错误__:NGHTTP2_FLOW_CONTROL_ERROR }
        常量 __NGHTTP2_流_控制_错误__: 数字;

        //@@{ __NGHTTP2_设置_超时__:NGHTTP2_SETTINGS_TIMEOUT }
        常量 __NGHTTP2_设置_超时__: 数字;

        //@@{ __NGHTTP2_流_关闭__:NGHTTP2_STREAM_CLOSED }
        常量 __NGHTTP2_流_关闭__: 数字;

        //@@{ __NGHTTP2_框架_大小_错误__:NGHTTP2_FRAME_SIZE_ERROR }
        常量 __NGHTTP2_框架_大小_错误__: 数字;

        //@@{ __NGHTTP2_拒绝_流__:NGHTTP2_REFUSED_STREAM }
        常量 __NGHTTP2_拒绝_流__: 数字;

        //@@{ __NGHTTP2_取消__:NGHTTP2_CANCEL }
        常量 __NGHTTP2_取消__: 数字;

        //@@{ __NGHTTP2_压缩_错误__:NGHTTP2_COMPRESSION_ERROR }
        常量 __NGHTTP2_压缩_错误__: 数字;

        //@@{ __NGHTTP2_连接_错误__:NGHTTP2_CONNECT_ERROR }
        常量 __NGHTTP2_连接_错误__: 数字;

        //@@{ __NGHTTP2_增强_你的_平静__:NGHTTP2_ENHANCE_YOUR_CALM }
        常量 __NGHTTP2_增强_你的_平静__: 数字;

        //@@{ __NGHTTP2_不充分的_安全__:NGHTTP2_INADEQUATE_SECURITY }
        常量 __NGHTTP2_不充分的_安全__: 数字;

        //@@{ __NGHTTP2_HTTP_1_1_请求__:NGHTTP2_HTTP_1_1_REQUIRED }
        常量 __NGHTTP2_HTTP_1_1_请求__: 数字;

        //@@{ __NGHTTP2_错误_框架_大小_错误__:NGHTTP2_ERR_FRAME_SIZE_ERROR }
        常量 __NGHTTP2_错误_框架_大小_错误__: 数字;

        //@@{ __NGHTTP2_标志_没有__:NGHTTP2_FLAG_NONE }
        常量 __NGHTTP2_标志_没有__: 数字;

        //@@{ __NGHTTP2_标志_结束_流__:NGHTTP2_FLAG_END_STREAM }
        常量 __NGHTTP2_标志_结束_流__: 数字;

        //@@{ __NGHTTP2_标志_结束_头__:NGHTTP2_FLAG_END_HEADERS }
        常量 __NGHTTP2_标志_结束_头__: 数字;

        //@@{ __NGHTTP2_标志_ACK__:NGHTTP2_FLAG_ACK }
        常量 __NGHTTP2_标志_ACK__: 数字;

        //@@{ __NGHTTP2_标志_面板__:NGHTTP2_FLAG_PADDED }
        常量 __NGHTTP2_标志_面板__: 数字;

        //@@{ __NGHTTP2_标志_优先级__:NGHTTP2_FLAG_PRIORITY }
        常量 __NGHTTP2_标志_优先级__: 数字;

        //@@{ __默认的_设置_头_表_大小__:DEFAULT_SETTINGS_HEADER_TABLE_SIZE }
        常量 __默认的_设置_头_表_大小__: 数字;

        //@@{ __默认的_设置_启用_压住__:DEFAULT_SETTINGS_ENABLE_PUSH }
        常量 __默认的_设置_启用_压住__: 数字;

        //@@{ __默认的_设置_最初_窗口_大小__:DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE }
        常量 __默认的_设置_最初_窗口_大小__: 数字;

        //@@{ __默认的_设置_最大_框架_大小__:DEFAULT_SETTINGS_MAX_FRAME_SIZE }
        常量 __默认的_设置_最大_框架_大小__: 数字;

        //@@{ __最大_最大_框架_大小__:MAX_MAX_FRAME_SIZE }
        常量 __最大_最大_框架_大小__: 数字;

        //@@{ __最小_最大_框架_大小__:MIN_MAX_FRAME_SIZE }
        常量 __最小_最大_框架_大小__: 数字;

        //@@{ __最大_最初_窗口_大小__:MAX_INITIAL_WINDOW_SIZE }
        常量 __最大_最初_窗口_大小__: 数字;

        //@@{ __NGHTTP2_默认的_重量__:NGHTTP2_DEFAULT_WEIGHT }
        常量 __NGHTTP2_默认的_重量__: 数字;

        //@@{ __NGHTTP2_设置_头_表_大小__:NGHTTP2_SETTINGS_HEADER_TABLE_SIZE }
        常量 __NGHTTP2_设置_头_表_大小__: 数字;

        //@@{ __NGHTTP2_设置_启用_压入__:NGHTTP2_SETTINGS_ENABLE_PUSH }
        常量 __NGHTTP2_设置_启用_压入__: 数字;

        //@@{ __NGHTTP2_设置_最大_并发_流__:NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS }
        常量 __NGHTTP2_设置_最大_并发_流__: 数字;

        //@@{ __NGHTTP2_设置_最初的_窗口_大小__:NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE }
        常量 __NGHTTP2_设置_最初的_窗口_大小__: 数字;

        //@@{ __NGHTTP2_设置_最大_框架_大小__:NGHTTP2_SETTINGS_MAX_FRAME_SIZE }
        常量 __NGHTTP2_设置_最大_框架_大小__: 数字;

        //@@{ __NGHTTP2_设置_最大_头_列表_大小__:NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE }
        常量 __NGHTTP2_设置_最大_头_列表_大小__: 数字;

        //@@{ __填充_策略_没有__:PADDING_STRATEGY_NONE }
        常量 __填充_策略_没有__: 数字;

        //@@{ __填充_策略_最大__:PADDING_STRATEGY_MAX }
        常量 __填充_策略_最大__: 数字;

        //@@{ __填充_策略_回调__:PADDING_STRATEGY_CALLBACK }
        常量 __填充_策略_回调__: 数字;

        //@@{ __HTTP2_头_状态__:HTTP2_HEADER_STATUS }
        常量 __HTTP2_头_状态__: 文字;

        //@@{ __HTTP2_头_方法__:HTTP2_HEADER_METHOD }
        常量 __HTTP2_头_方法__: 文字;

        //@@{ __HTTP2_头_权威__:HTTP2_HEADER_AUTHORITY }
        常量 __HTTP2_头_权威__: 文字;

        //@@{ __HTTP2_头_计划__:HTTP2_HEADER_SCHEME }
        常量 __HTTP2_头_计划__: 文字;

        //@@{ __HTTP2_头_路径__:HTTP2_HEADER_PATH }
        常量 __HTTP2_头_路径__: 文字;

        //@@{ __HTTP2_头_接受_字符集__:HTTP2_HEADER_ACCEPT_CHARSET }
        常量 __HTTP2_头_接受_字符集__: 文字;

        //@@{ __HTTP2_头_接受_编码__:HTTP2_HEADER_ACCEPT_ENCODING }
        常量 __HTTP2_头_接受_编码__: 文字;

        //@@{ __HTTP2_头_接受_语言__:HTTP2_HEADER_ACCEPT_LANGUAGE }
        常量 __HTTP2_头_接受_语言__: 文字;

        //@@{ __HTTP2_头_接受_范围__:HTTP2_HEADER_ACCEPT_RANGES }
        常量 __HTTP2_头_接受_范围__: 文字;

        //@@{ __HTTP2_头_接受__:HTTP2_HEADER_ACCEPT }
        常量 __HTTP2_头_接受__: 文字;

        //@@{ __HTTP2_头_访问_控制_允许_起源__:HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN }
        常量 __HTTP2_头_访问_控制_允许_起源__: 文字;

        //@@{ __HTTP2_头_年龄__:HTTP2_HEADER_AGE }
        常量 __HTTP2_头_年龄__: 文字;

        //@@{ __HTTP2_头_允许__:HTTP2_HEADER_ALLOW }
        常量 __HTTP2_头_允许__: 文字;

        //@@{ __HTTP2_头_授权__:HTTP2_HEADER_AUTHORIZATION }
        常量 __HTTP2_头_授权__: 文字;

        //@@{ __HTTP2_头_缓存_控制__:HTTP2_HEADER_CACHE_CONTROL }
        常量 __HTTP2_头_缓存_控制__: 文字;

        //@@{ __HTTP2_头_连接__:HTTP2_HEADER_CONNECTION }
        常量 __HTTP2_头_连接__: 文字;

        //@@{ __HTTP2_头_内容_性格__:HTTP2_HEADER_CONTENT_DISPOSITION }
        常量 __HTTP2_头_内容_性格__: 文字;

        //@@{ __HTTP2_头_内容_编码__:HTTP2_HEADER_CONTENT_ENCODING }
        常量 __HTTP2_头_内容_编码__: 文字;

        //@@{ __HTTP2_头_内容_语言__:HTTP2_HEADER_CONTENT_LANGUAGE }
        常量 __HTTP2_头_内容_语言__: 文字;

        //@@{ __HTTP2_头_内容_长度__:HTTP2_HEADER_CONTENT_LENGTH }
        常量 __HTTP2_头_内容_长度__: 文字;

        //@@{ __HTTP2_头_内容_位置__:HTTP2_HEADER_CONTENT_LOCATION }
        常量 __HTTP2_头_内容_位置__: 文字;

        //@@{ __HTTP2_头_内容_MD5__:HTTP2_HEADER_CONTENT_MD5 }
        常量 __HTTP2_头_内容_MD5__: 文字;

        //@@{ __HTTP2_头_内容_范围__:HTTP2_HEADER_CONTENT_RANGE }
        常量 __HTTP2_头_内容_范围__: 文字;

        //@@{ __HTTP2_头_内容_类型__:HTTP2_HEADER_CONTENT_TYPE }
        常量 __HTTP2_头_内容_类型__: 文字;

        //@@{ __HTTP2_头_浏览器缓存__:HTTP2_HEADER_COOKIE }
        常量 __HTTP2_头_浏览器缓存__: 文字;

        //@@{ __HTTP2_头_日期__:HTTP2_HEADER_DATE }
        常量 __HTTP2_头_日期__: 文字;

        //@@{ __HTTP2_头_ETAG__:HTTP2_HEADER_ETAG }
        常量 __HTTP2_头_ETAG__: 文字;

        //@@{ __HTTP2_头_预计__:HTTP2_HEADER_EXPECT }
        常量 __HTTP2_头_预计__: 文字;

        //@@{ __HTTP2_头_到期__:HTTP2_HEADER_EXPIRES }
        常量 __HTTP2_头_到期__: 文字;

        //@@{ __HTTP2_头_表单__:HTTP2_HEADER_FROM }
        常量 __HTTP2_头_表单__: 文字;

        //@@{ __HTTP2_头_主机__:HTTP2_HEADER_HOST }
        常量 __HTTP2_头_主机__: 文字;

        //@@{ __HTTP2_头_如果_匹配__:HTTP2_HEADER_IF_MATCH }
        常量 __HTTP2_头_如果_匹配__: 文字;

        //@@{ __HTTP2_头_如果_修改_以后__:HTTP2_HEADER_IF_MODIFIED_SINCE }
        常量 __HTTP2_头_如果_修改_以后__: 文字;

        //@@{ __HTTP2_头_如果_没有_匹配__:HTTP2_HEADER_IF_NONE_MATCH }
        常量 __HTTP2_头_如果_没有_匹配__: 文字;

        //@@{ __HTTP2_头_如果_范围__:HTTP2_HEADER_IF_RANGE }
        常量 __HTTP2_头_如果_范围__: 文字;

        //@@{ __HTTP2_头_如果_未修改_以后__:HTTP2_HEADER_IF_UNMODIFIED_SINCE }
        常量 __HTTP2_头_如果_未修改_以后__: 文字;

        //@@{ __HTTP2_头_最后_修改__:HTTP2_HEADER_LAST_MODIFIED }
        常量 __HTTP2_头_最后_修改__: 文字;

        //@@{ __HTTP2_头_链接__:HTTP2_HEADER_LINK }
        常量 __HTTP2_头_链接__: 文字;

        //@@{ __HTTP2_头_位置__:HTTP2_HEADER_LOCATION }
        常量 __HTTP2_头_位置__: 文字;

        //@@{ __HTTP2_头_最大_转发__:HTTP2_HEADER_MAX_FORWARDS }
        常量 __HTTP2_头_最大_转发__: 文字;

        //@@{ __HTTP2_头_更喜欢__:HTTP2_HEADER_PREFER }
        常量 __HTTP2_头_更喜欢__: 文字;

        //@@{ __HTTP2_头_代理_进行身份验证__:HTTP2_HEADER_PROXY_AUTHENTICATE }
        常量 __HTTP2_头_代理_进行身份验证__: 文字;

        //@@{ __HTTP2_头_代理_授权__:HTTP2_HEADER_PROXY_AUTHORIZATION }
        常量 __HTTP2_头_代理_授权__: 文字;

        //@@{ __HTTP2_头_范围__:HTTP2_HEADER_RANGE }
        常量 __HTTP2_头_范围__: 文字;

        //@@{ __HTTP2_头_推荐人__:HTTP2_HEADER_REFERER }
        常量 __HTTP2_头_推荐人__: 文字;

        //@@{ __HTTP2_头_刷新__:HTTP2_HEADER_REFRESH }
        常量 __HTTP2_头_刷新__: 文字;

        //@@{ __HTTP2_头_重试_后__:HTTP2_HEADER_RETRY_AFTER }
        常量 __HTTP2_头_重试_后__: 文字;

        //@@{ __HTTP2_头_服务器__:HTTP2_HEADER_SERVER }
        常量 __HTTP2_头_服务器__: 文字;

        //@@{ __HTTP2_头_集_浏览器缓存__:HTTP2_HEADER_SET_COOKIE }
        常量 __HTTP2_头_集_浏览器缓存__: 文字;

        //@@{ __HTTP2_头_严格的_运输_安全__:HTTP2_HEADER_STRICT_TRANSPORT_SECURITY }
        常量 __HTTP2_头_严格的_运输_安全__: 文字;

        //@@{ __HTTP2_头_转移_编码__:HTTP2_HEADER_TRANSFER_ENCODING }
        常量 __HTTP2_头_转移_编码__: 文字;

        //@@{ __HTTP2_头_TE__:HTTP2_HEADER_TE }
        常量 __HTTP2_头_TE__: 文字;

        //@@{ __HTTP2_头_升级__:HTTP2_HEADER_UPGRADE }
        常量 __HTTP2_头_升级__: 文字;

        //@@{ __HTTP2_头_用户_代理__:HTTP2_HEADER_USER_AGENT }
        常量 __HTTP2_头_用户_代理__: 文字;

        //@@{ __HTTP2_头_不同__:HTTP2_HEADER_VARY }
        常量 __HTTP2_头_不同__: 文字;

        //@@{ __HTTP2_头_通过__:HTTP2_HEADER_VIA }
        常量 __HTTP2_头_通过__: 文字;

        //@@{ __HTTP2_头_WWW_进行身份验证__:HTTP2_HEADER_WWW_AUTHENTICATE }
        常量 __HTTP2_头_WWW_进行身份验证__: 文字;

        //@@{ __HTTP2_头_HTTP2_设置__:HTTP2_HEADER_HTTP2_SETTINGS }
        常量 __HTTP2_头_HTTP2_设置__: 文字;

        //@@{ __HTTP2_头_保持_活着__:HTTP2_HEADER_KEEP_ALIVE }
        常量 __HTTP2_头_保持_活着__: 文字;

        //@@{ __HTTP2_头_代理_连接__:HTTP2_HEADER_PROXY_CONNECTION }
        常量 __HTTP2_头_代理_连接__: 文字;

        //@@{ __HTTP2_方法_ACL__:HTTP2_METHOD_ACL }
        常量 __HTTP2_方法_ACL__: 文字;

        //@@{ __HTTP2_方法_基线_控制__:HTTP2_METHOD_BASELINE_CONTROL }
        常量 __HTTP2_方法_基线_控制__: 文字;

        //@@{ __HTTP2_方法_绑定__:HTTP2_METHOD_BIND }
        常量 __HTTP2_方法_绑定__: 文字;

        //@@{ __HTTP2_方法_签入__:HTTP2_METHOD_CHECKIN }
        常量 __HTTP2_方法_签入__: 文字;

        //@@{ __HTTP2_方法_结帐__:HTTP2_METHOD_CHECKOUT }
        常量 __HTTP2_方法_结帐__: 文字;

        //@@{ __HTTP2_方法_连接__:HTTP2_METHOD_CONNECT }
        常量 __HTTP2_方法_连接__: 文字;

        //@@{ __HTTP2_方法_复制__:HTTP2_METHOD_COPY }
        常量 __HTTP2_方法_复制__: 文字;

        //@@{ __HTTP2_方法_删除__:HTTP2_METHOD_DELETE }
        常量 __HTTP2_方法_删除__: 文字;

        //@@{ __HTTP2_方法_GET__:HTTP2_METHOD_GET }
        常量 __HTTP2_方法_GET__: 文字;

        //@@{ __HTTP2_方法_HEAD__:HTTP2_METHOD_HEAD }
        常量 __HTTP2_方法_HEAD__: 文字;

        //@@{ __HTTP2_方法_标签__:HTTP2_METHOD_LABEL }
        常量 __HTTP2_方法_标签__: 文字;

        //@@{ __HTTP2_方法_链接__:HTTP2_METHOD_LINK }
        常量 __HTTP2_方法_链接__: 文字;

        //@@{ __HTTP2_方法_锁__:HTTP2_METHOD_LOCK }
        常量 __HTTP2_方法_锁__: 文字;

        //@@{ __HTTP2_方法_合并__:HTTP2_METHOD_MERGE }
        常量 __HTTP2_方法_合并__: 文字;

        //@@{ __HTTP2_方法_MK活动__:HTTP2_METHOD_MKACTIVITY }
        常量 __HTTP2_方法_MK活动__: 文字;

        //@@{ __HTTP2_方法_MK日历__:HTTP2_METHOD_MKCALENDAR }
        常量 __HTTP2_方法_MK日历__: 文字;

        //@@{ __HTTP2_方法_MKCOL__:HTTP2_METHOD_MKCOL }
        常量 __HTTP2_方法_MKCOL__: 文字;

        //@@{ __HTTP2_方法_MK重定向参考__:HTTP2_METHOD_MKREDIRECTREF }
        常量 __HTTP2_方法_MK重定向参考__: 文字;

        //@@{ __HTTP2_方法_MK工作空间__:HTTP2_METHOD_MKWORKSPACE }
        常量 __HTTP2_方法_MK工作空间__: 文字;

        //@@{ __HTTP2_方法_移动__:HTTP2_METHOD_MOVE }
        常量 __HTTP2_方法_移动__: 文字;

        //@@{ __HTTP2_方法_选项__:HTTP2_METHOD_OPTIONS }
        常量 __HTTP2_方法_选项__: 文字;

        //@@{ __HTTP2_方法_为了修补__:HTTP2_METHOD_ORDERPATCH }
        常量 __HTTP2_方法_为了修补__: 文字;

        //@@{ __HTTP2_方法_补丁__:HTTP2_METHOD_PATCH }
        常量 __HTTP2_方法_补丁__: 文字;

        //@@{ __HTTP2_方法_POST__:HTTP2_METHOD_POST }
        常量 __HTTP2_方法_POST__: 文字;

        //@@{ __HTTP2_方法_PRI__:HTTP2_METHOD_PRI }
        常量 __HTTP2_方法_PRI__: 文字;

        //@@{ __HTTP2_方法_道具找到__:HTTP2_METHOD_PROPFIND }
        常量 __HTTP2_方法_道具找到__: 文字;

        //@@{ __HTTP2_方法_道具补丁__:HTTP2_METHOD_PROPPATCH }
        常量 __HTTP2_方法_道具补丁__: 文字;

        //@@{ __HTTP2_方法_PUT__:HTTP2_METHOD_PUT }
        常量 __HTTP2_方法_PUT__: 文字;

        //@@{ __HTTP2_方法_重新绑定__:HTTP2_METHOD_REBIND }
        常量 __HTTP2_方法_重新绑定__: 文字;

        //@@{ __HTTP2_方法_报告__:HTTP2_METHOD_REPORT }
        常量 __HTTP2_方法_报告__: 文字;

        //@@{ __HTTP2_方法_搜索__:HTTP2_METHOD_SEARCH }
        常量 __HTTP2_方法_搜索__: 文字;

        //@@{ __HTTP2_方法_跟踪__:HTTP2_METHOD_TRACE }
        常量 __HTTP2_方法_跟踪__: 文字;

        //@@{ __HTTP2_方法_解开__:HTTP2_METHOD_UNBIND }
        常量 __HTTP2_方法_解开__: 文字;

        //@@{ __HTTP2_方法_未结算__:HTTP2_METHOD_UNCHECKOUT }
        常量 __HTTP2_方法_未结算__: 文字;

        //@@{ __HTTP2_方法_未链接__:HTTP2_METHOD_UNLINK }
        常量 __HTTP2_方法_未链接__: 文字;

        //@@{ __HTTP2_方法_解锁__:HTTP2_METHOD_UNLOCK }
        常量 __HTTP2_方法_解锁__: 文字;

        //@@{ __HTTP2_方法_更新__:HTTP2_METHOD_UPDATE }
        常量 __HTTP2_方法_更新__: 文字;

        //@@{ __HTTP2_方法_更新重定向参考__:HTTP2_METHOD_UPDATEREDIRECTREF }
        常量 __HTTP2_方法_更新重定向参考__: 文字;

        //@@{ __HTTP2_方法_版本_控制__:HTTP2_METHOD_VERSION_CONTROL }
        常量 __HTTP2_方法_版本_控制__: 文字;

        //@@{ __HTTP_状态_继续__:HTTP_STATUS_CONTINUE }
        常量 __HTTP_状态_继续__: 数字;

        //@@{ __HTTP_状态_切换_协议__:HTTP_STATUS_SWITCHING_PROTOCOLS }
        常量 __HTTP_状态_切换_协议__: 数字;

        //@@{ __HTTP_状态_处理__:HTTP_STATUS_PROCESSING }
        常量 __HTTP_状态_处理__: 数字;

        //@@{ __HTTP_状态_OK__:HTTP_STATUS_OK }
        常量 __HTTP_状态_OK__: 数字;

        //@@{ __HTTP_状态_创建__:HTTP_STATUS_CREATED }
        常量 __HTTP_状态_创建__: 数字;

        //@@{ __HTTP_状态_接受__:HTTP_STATUS_ACCEPTED }
        常量 __HTTP_状态_接受__: 数字;

        //@@{ __HTTP_状态_非_权威的_信息__:HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION }
        常量 __HTTP_状态_非_权威的_信息__: 数字;

        //@@{ __HTTP_状态_没有_内容__:HTTP_STATUS_NO_CONTENT }
        常量 __HTTP_状态_没有_内容__: 数字;

        //@@{ __HTTP_状态_重置_内容__:HTTP_STATUS_RESET_CONTENT }
        常量 __HTTP_状态_重置_内容__: 数字;

        //@@{ __HTTP_状态_部分_内容__:HTTP_STATUS_PARTIAL_CONTENT }
        常量 __HTTP_状态_部分_内容__: 数字;

        //@@{ __HTTP_状态_多_状态__:HTTP_STATUS_MULTI_STATUS }
        常量 __HTTP_状态_多_状态__: 数字;

        //@@{ __HTTP_状态_已经_报道__:HTTP_STATUS_ALREADY_REPORTED }
        常量 __HTTP_状态_已经_报道__: 数字;

        //@@{ __HTTP_状态_即时通讯_使用__:HTTP_STATUS_IM_USED }
        常量 __HTTP_状态_即时通讯_使用__: 数字;

        //@@{ __HTTP_状态_多个_选择__:HTTP_STATUS_MULTIPLE_CHOICES }
        常量 __HTTP_状态_多个_选择__: 数字;

        //@@{ __HTTP_状态_移动_永久__:HTTP_STATUS_MOVED_PERMANENTLY }
        常量 __HTTP_状态_移动_永久__: 数字;

        //@@{ __HTTP_状态_发现__:HTTP_STATUS_FOUND }
        常量 __HTTP_状态_发现__: 数字;

        //@@{ __HTTP_状态_看到_其他__:HTTP_STATUS_SEE_OTHER }
        常量 __HTTP_状态_看到_其他__: 数字;

        //@@{ __HTTP_状态_不_修改__:HTTP_STATUS_NOT_MODIFIED }
        常量 __HTTP_状态_不_修改__: 数字;

        //@@{ __HTTP_状态_使用_代理__:HTTP_STATUS_USE_PROXY }
        常量 __HTTP_状态_使用_代理__: 数字;

        //@@{ __HTTP_状态_临时_重定向__:HTTP_STATUS_TEMPORARY_REDIRECT }
        常量 __HTTP_状态_临时_重定向__: 数字;

        //@@{ __HTTP_状态_永久_重定向__:HTTP_STATUS_PERMANENT_REDIRECT }
        常量 __HTTP_状态_永久_重定向__: 数字;

        //@@{ __HTTP_状态_坏_请求__:HTTP_STATUS_BAD_REQUEST }
        常量 __HTTP_状态_坏_请求__: 数字;

        //@@{ __HTTP_状态_未经授权的__:HTTP_STATUS_UNAUTHORIZED }
        常量 __HTTP_状态_未经授权的__: 数字;

        //@@{ __HTTP_状态_付款_要求__:HTTP_STATUS_PAYMENT_REQUIRED }
        常量 __HTTP_状态_付款_要求__: 数字;

        //@@{ __HTTP_状态_被禁止的__:HTTP_STATUS_FORBIDDEN }
        常量 __HTTP_状态_被禁止的__: 数字;

        //@@{ __HTTP_状态_不_发现__:HTTP_STATUS_NOT_FOUND }
        常量 __HTTP_状态_不_发现__: 数字;

        //@@{ __HTTP_状态_方法_不_允许__:HTTP_STATUS_METHOD_NOT_ALLOWED }
        常量 __HTTP_状态_方法_不_允许__: 数字;

        //@@{ __HTTP_状态_不_可接受的__:HTTP_STATUS_NOT_ACCEPTABLE }
        常量 __HTTP_状态_不_可接受的__: 数字;

        //@@{ __HTTP_状态_代理_身份验证_要求__:HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED }
        常量 __HTTP_状态_代理_身份验证_要求__: 数字;

        //@@{ __HTTP_状态_请求_超时__:HTTP_STATUS_REQUEST_TIMEOUT }
        常量 __HTTP_状态_请求_超时__: 数字;

        //@@{ __HTTP_状态_冲突__:HTTP_STATUS_CONFLICT }
        常量 __HTTP_状态_冲突__: 数字;

        //@@{ __HTTP_状态_走了__:HTTP_STATUS_GONE }
        常量 __HTTP_状态_走了__: 数字;

        //@@{ __HTTP_状态_长度_要求__:HTTP_STATUS_LENGTH_REQUIRED }
        常量 __HTTP_状态_长度_要求__: 数字;

        //@@{ __HTTP_状态_先决条件_失败的__:HTTP_STATUS_PRECONDITION_FAILED }
        常量 __HTTP_状态_先决条件_失败的__: 数字;

        //@@{ __HTTP_状态_有效载荷_太_大__:HTTP_STATUS_PAYLOAD_TOO_LARGE }
        常量 __HTTP_状态_有效载荷_太_大__: 数字;

        //@@{ __HTTP_状态_URI_太_长__:HTTP_STATUS_URI_TOO_LONG }
        常量 __HTTP_状态_URI_太_长__: 数字;

        //@@{ __HTTP_状态_不支持的_媒体_类型__:HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE }
        常量 __HTTP_状态_不支持的_媒体_类型__: 数字;

        //@@{ __HTTP_状态_范围_不_可以满足的__:HTTP_STATUS_RANGE_NOT_SATISFIABLE }
        常量 __HTTP_状态_范围_不_可以满足的__: 数字;

        //@@{ __HTTP_状态_期望_失败的__:HTTP_STATUS_EXPECTATION_FAILED }
        常量 __HTTP_状态_期望_失败的__: 数字;

        //@@{ __HTTP_状态_茶壶__:HTTP_STATUS_TEAPOT }
        常量 __HTTP_状态_茶壶__: 数字;

        //@@{ __HTTP_状态_被误导_请求__:HTTP_STATUS_MISDIRECTED_REQUEST }
        常量 __HTTP_状态_被误导_请求__: 数字;

        //@@{ __HTTP_状态_不可加工_实体__:HTTP_STATUS_UNPROCESSABLE_ENTITY }
        常量 __HTTP_状态_不可加工_实体__: 数字;

        //@@{ __HTTP_状态_锁着的__:HTTP_STATUS_LOCKED }
        常量 __HTTP_状态_锁着的__: 数字;

        //@@{ __HTTP_状态_失败的_依赖__:HTTP_STATUS_FAILED_DEPENDENCY }
        常量 __HTTP_状态_失败的_依赖__: 数字;

        //@@{ __HTTP_状态_无序_集合__:HTTP_STATUS_UNORDERED_COLLECTION }
        常量 __HTTP_状态_无序_集合__: 数字;

        //@@{ __HTTP_状态_升级_要求__:HTTP_STATUS_UPGRADE_REQUIRED }
        常量 __HTTP_状态_升级_要求__: 数字;

        //@@{ __HTTP_状态_先决条件_要求__:HTTP_STATUS_PRECONDITION_REQUIRED }
        常量 __HTTP_状态_先决条件_要求__: 数字;

        //@@{ __HTTP_状态_太_许多_请求__:HTTP_STATUS_TOO_MANY_REQUESTS }
        常量 __HTTP_状态_太_许多_请求__: 数字;

        //@@{ __HTTP_状态_请求_头_字段_太_大__:HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE }
        常量 __HTTP_状态_请求_头_字段_太_大__: 数字;

        //@@{ __HTTP_状态_不可用_为_法律_原因__:HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS }
        常量 __HTTP_状态_不可用_为_法律_原因__: 数字;

        //@@{ __HTTP_状态_内部_服务器_错误__:HTTP_STATUS_INTERNAL_SERVER_ERROR }
        常量 __HTTP_状态_内部_服务器_错误__: 数字;

        //@@{ __HTTP_状态_不_实现__:HTTP_STATUS_NOT_IMPLEMENTED }
        常量 __HTTP_状态_不_实现__: 数字;

        //@@{ __HTTP_状态_坏_网关__:HTTP_STATUS_BAD_GATEWAY }
        常量 __HTTP_状态_坏_网关__: 数字;

        //@@{ __HTTP_状态_服务_不可用__:HTTP_STATUS_SERVICE_UNAVAILABLE }
        常量 __HTTP_状态_服务_不可用__: 数字;

        //@@{ __HTTP_状态_网关_超时__:HTTP_STATUS_GATEWAY_TIMEOUT }
        常量 __HTTP_状态_网关_超时__: 数字;

        //@@{ __HTTP_状态_HTTP_版本_不_支持__:HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED }
        常量 __HTTP_状态_HTTP_版本_不_支持__: 数字;

        //@@{ __HTTP_状态_变体_也_协商__:HTTP_STATUS_VARIANT_ALSO_NEGOTIATES }
        常量 __HTTP_状态_变体_也_协商__: 数字;

        //@@{ __HTTP_状态_不足_存储__:HTTP_STATUS_INSUFFICIENT_STORAGE }
        常量 __HTTP_状态_不足_存储__: 数字;

        //@@{ __HTTP_状态_循环_检测到__:HTTP_STATUS_LOOP_DETECTED }
        常量 __HTTP_状态_循环_检测到__: 数字;

        //@@{ __HTTP_状态_带宽_限制_超过了__:HTTP_STATUS_BANDWIDTH_LIMIT_EXCEEDED }
        常量 __HTTP_状态_带宽_限制_超过了__: 数字;

        //@@{ __HTTP_状态_不_扩展__:HTTP_STATUS_NOT_EXTENDED }
        常量 __HTTP_状态_不_扩展__: 数字;

        //@@{ __HTTP_状态_网络_身份验证_要求__:HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED }
        常量 __HTTP_状态_网络_身份验证_要求__: 数字;
    }

    //@@{ 获取默认配置:getDefaultSettings, 配置_:Settings }
    导出 函数 获取默认配置(): 配置_;

    //@@{ 获取序列化包配置:getPackedSettings, 配置_:Settings, 缓冲区_:Buffer }
    导出 函数 获取序列化包配置(配置: 配置_): 缓冲区_;

    //@@{ 获取反序列化包配置:getUnpackedSettings, 缓冲区_:Buffer, 正整数数组8_:Uint8Array, 配置_:Settings }
    导出 函数 获取反序列化包配置(缓冲: 缓冲区_ | 正整数数组8_): 配置_;

    //@@{ 创建服务器:createServer, Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse }
    //@@{ Http2服务器_:Http2Server }
    导出 函数 创建服务器(正在请求处理程序?: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): Http2服务器_;

    //@@{ 创建服务器:createServer, 服务器选项_:ServerOptions, Http2服务器请求_:Http2ServerRequest }
    //@@{ Http2服务器响应_:Http2ServerResponse, Http2服务器_:Http2Server }
    导出 函数 创建服务器(选项组: 服务器选项_, 正在请求处理程序?: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): Http2服务器_;

    //@@{ 创建安全服务器:createSecureServer, Http2服务器请求_:Http2ServerRequest, Http2服务器响应_:Http2ServerResponse }
    //@@{ Http2安全服务器_:Http2SecureServer }
    导出 函数 创建安全服务器(正在请求处理程序?: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): Http2安全服务器_;

    //@@{ 创建安全服务器:createSecureServer, 安全服务器选项_:SecureServerOptions, Http2服务器请求_:Http2ServerRequest }
    //@@{ Http2服务器响应_:Http2ServerResponse, Http2安全服务器_:Http2SecureServer }
    导出 函数 创建安全服务器(选项组: 安全服务器选项_, 正在请求处理程序?: (请求: Http2服务器请求_, 响应: Http2服务器响应_) => 无值): Http2安全服务器_;

    //@@{ 连接:connect, 客户端Http2会话_:ClientHttp2Session, 网:net, 套接字_:Socket, TLS套接字_:TLSSocket }
    导出 函数 连接(权威: 文字 | url.URL, 监听器?: (会话: 客户端Http2会话_, 套接字: 网.套接字_ | tls.TLS套接字_) => 无值): 客户端Http2会话_;

    //@@{ 连接:connect }
    导出 函数 连接(
        权威: 文字 | url.URL,

        //@@{ 客户端会话选项_:ClientSessionOptions, 安全客户端会话选项_:SecureClientSessionOptions }
        选项组?: 客户端会话选项_ | 安全客户端会话选项_,

        //@@{ 客户端Http2会话_:ClientHttp2Session, 网:net, 套接字_:Socket, TLS套接字_:TLSSocket }
        监听器?: (会话: 客户端Http2会话_, 套接字: 网.套接字_ | tls.TLS套接字_) => 无值,

    //@@{ 客户端Http2会话_:ClientHttp2Session }
    ): 客户端Http2会话_;
}
